doc
Module Contents
alltypes
Module Contents
interface AbsentThrowableMessageProviderFactory
object AbsentThrowableMessageProviderFactoryBuilder : AbsentThrowableMessageProviderFactory
class All<out T> : VarArgHelper<T>
interface AnyAssertions
Module Contents
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
abstract fun <T : Any> isNotNullBut(plant: AssertionPlantNullable<T?>, type: KClass<T>, expected: T): Assertion
abstract fun <T : Any> isNotSame(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T> isNull(plant: AssertionPlantNullable<T>): Assertion
abstract fun <T : Any> isNullIfNullGivenElse(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreatorOrNull: AssertionPlant<T>.() -> Unit): Assertion
abstract fun <T : Any> isNullable(plant: AssertionPlantNullable<T?>, type: KClass<T>, expectedOrNull: T?): Assertion
abstract fun <T : Any> isSame(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : Any> notToBe(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : Any> toBe(plant: AssertionPlant<T>, expected: T): Assertion
object AnyAssertionsBuilder : AnyAssertions
Module Contents
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNotNullBut(plant: AssertionPlantNullable<T?>, type: KClass<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> isNotSame(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T> isNull(plant: AssertionPlantNullable<T>): <ERROR CLASS>
inline fun <T : Any> isNullIfNullGivenElse(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreatorOrNull: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNullable(plant: AssertionPlantNullable<T?>, type: KClass<T>, expectedOrNull: T?): <ERROR CLASS>
inline fun <T : Any> isSame(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> notToBe(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> toBe(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline val typeTransformation: AnyTypeTransformationAssertionsBuilder
interface AnyTypeTransformation
interface AnyTypeTransformation
interface AnyTypeTransformationAssertions
Module Contents
abstract fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): Unit
abstract fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Unit
abstract fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: FailureHandler<S, T>): Unit
object AnyTypeTransformationAssertionsBuilder : AnyTypeTransformationAssertions
Module Contents
inline fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): <ERROR CLASS>
inline val failureHandlers: AnyTypeTransformationFailureHandlerFactoryBuilder
inline fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, noinline canBeTransformed: (S) -> Boolean, noinline transform: (S) -> T, failureHandler: FailureHandler<S, T>): <ERROR CLASS>
object AnyTypeTransformationFailureHandlerFactoryBuilder : FailureHandlerFactory
class ArgumentMapperBuilder<out T>
class ArgumentToNullOrMapperBuilder<T : Any>
abstract class ArgumentsSupportingTranslator : Translator
typealias Assert<T> = AssertionPlant<T>
object AssertImpl : AssertImplCommon
interface AssertImplCommon
@DslMarker annotation class AssertMarker
interface Assertion
interface AssertionBuilder
interface AssertionBuilderFinalStep<T : Assertion>
interface AssertionChecker
interface AssertionCollector
Module Contents
open fun <T : Any> collect(plant: AssertionPlant<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
open fun <T : Any> collect(subjectProvider: () -> T, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(subjectProvider: () -> T, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): AssertionGroup
open fun <T> collectNullable(plant: AssertionPlantNullable<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullable(subjectProvider: () -> T, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullableOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, plant: AssertionPlantNullable<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullableOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T : Any> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, plant: AssertionPlant<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
open fun <T : Any> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): AssertionGroup
object AssertionCollectorBuilder : AssertionCollector
Module Contents
inline fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(noinline subjectProvider: () -> T, noinline collectingPlantFactory: (() -> T) -> C, noinline assertionCreator: C.() -> Unit): AssertionGroup
inline fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, noinline subjectProvider: () -> T, noinline collectingPlantFactory: (() -> T) -> C, noinline assertionCreator: C.() -> Unit): AssertionGroup
inline val forExplanation: ExplainingAssertionCollectorOption
interface AssertionCollectorForExplanation
Module Contents
open fun <T : Any> collect(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): List<Assertion>
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): List<Assertion>
open fun <T> collectNullable(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): List<Assertion>
interface AssertionComposer
interface AssertionFormatter
data class AssertionFormatterChosenOptions
interface AssertionFormatterController
interface AssertionFormatterControllerOption
interface AssertionFormatterFacade
interface AssertionFormatterFacadeOption
class AssertionFormatterParameterObject
interface AssertionGroup : Assertion
interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>
interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>
interface AssertionGroupType : BulletPointIdentifier
interface AssertionPairFormatter
interface AssertionPairFormatterOption
interface AssertionPlant<out T : Any> : BaseAssertionPlant<T, AssertionPlant<T>>
interface AssertionPlantNullable<out T> : BaseAssertionPlant<T, AssertionPlantNullable<T>>
interface AssertionPlantWithCommonFields<out T>
enum class AssertionVerb : StringBasedTranslatable
enum class AssertionVerb : StringBasedTranslatable
object AssertionVerbFactory
interface AssertionsOption<out T : AssertionGroupType, out R>
Module Contents
fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
fun <T : AssertionGroupType> factoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtLeastCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class AtLeastCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class AtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>
expect class AtriumError : AssertionError
expect interface AtriumErrorAdjuster : AtriumErrorAdjusterCommon
interface AtriumErrorAdjusterCommon
interface AtriumErrorAdjusterCommonOption<R : Any>
interface AtriumErrorAdjusterOption : AtriumErrorAdjusterCommonOption<ReporterOption>
interface BaseAssertionPlant<out T, out A : BaseAssertionPlant<T, A>>
interface BaseCollectingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>, out C : BaseCollectingAssertionPlant<T, A, C>> : BaseAssertionPlant<T, A>
interface BaseReportingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : BaseAssertionPlant<T, A>, AssertionPlantWithCommonFields<T>
data class BasicAssertionGroup : AssertionGroup
interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
class BasicDescriptiveAssertion : DescriptiveAssertion
class BasicExplanatoryAssertion : ExplanatoryAssertion
interface BigDecimalAssertions
object BigDecimalAssertionsBuilder : BigDecimalAssertions
object Blank : Keyword
interface BulletPointIdentifier
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ButAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
Module Contents
ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int
abstract class ButAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
Module Contents
ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>
interface CharSequenceAssertions
object CharSequenceAssertionsBuilder : CharSequenceAssertions
interface CharSequenceContains
interface CharSequenceContains
class CharSequenceContainsAssertionCreator<T : CharSequence, S : SearchBehaviour> : ContainsObjectsAssertionCreator<T, Any, S, Checker>, Creator<T, Any>
interface CharSequenceContainsAssertions
Module Contents
abstract fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): AssertionGroup
object CharSequenceContainsAssertionsBuilder : CharSequenceContainsAssertions
Module Contents
inline fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline val searchBehaviours: CharSequenceContainsSearchBehaviourFactoryBuilder
inline fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
inline fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
class CharSequenceContainsAtLeastChecker : CharSequenceContainsChecker
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsAtLeastCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
class CharSequenceContainsAtMostChecker : CharSequenceContainsChecker
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
class CharSequenceContainsBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsButAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
Module Contents
CharSequenceContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilderBase<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int
abstract class CharSequenceContainsChecker : ContainsChecker, Checker
interface CharSequenceContainsCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<T, S>>, CheckerOption<T, S>
class CharSequenceContainsExactlyChecker : CharSequenceContainsChecker
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsExactlyCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
class CharSequenceContainsIgnoringCaseIndexSearcher : Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>
class CharSequenceContainsIgnoringCaseRegexSearcher : Searcher<CharSequenceContainsIgnoringCaseSearchBehaviour>
open class CharSequenceContainsIgnoringCaseSearchBehaviour : SearchBehaviour, IgnoringCaseSearchBehaviour
class CharSequenceContainsIndexSearcher : Searcher<CharSequenceContainsNoOpSearchBehaviour>
open class CharSequenceContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour
class CharSequenceContainsNotChecker : Checker
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsNotCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsNotOrAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotSearchBehaviour : CharSequenceContainsNoOpSearchBehaviour, NotSearchBehaviour
class CharSequenceContainsRegexSearcher : Searcher<CharSequenceContainsNoOpSearchBehaviour>
object CharSequenceContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> values(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> standardUebersetzungVon(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> wert(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> werte(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
interface CheckerFactory
interface CheckerFactory
interface CheckingAssertionPlant<out T : Any> : AssertionPlant<T>
interface CollectingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseCollectingAssertionPlant<T, AssertionPlant<T>, CollectingAssertionPlant<T>>
interface CollectingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseCollectingAssertionPlant<T, AssertionPlantNullable<T>, CollectingAssertionPlantNullable<T>>
interface CollectionAssertions
object CollectionAssertionsBuilder : CollectionAssertions
interface ComparableAssertions
object ComparableAssertionsBuilder : ComparableAssertions
interface Contains
interface Contains
abstract class ContainsAssertionCreator<T : Any, S, C : Checker> : Creator<T, S>
abstract class ContainsBuilder<out T : Any, out S : SearchBehaviour> : Builder<T, S>
abstract class ContainsChecker : Checker
interface ContainsCheckerBuilder<out T : Any, out S : SearchBehaviour, out C : Checker, out B : Builder<T, S>> : CheckerOption<T, S, C, B>
abstract class ContainsObjectsAssertionCreator<T : Any, S, B : SearchBehaviour, C : Checker> : ContainsAssertionCreator<T, S, C>
expect interface CoreFactory : CoreFactoryCommon
interface CoreFactoryCommon
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subjectProvider: () -> T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newCollectingPlantNullable(subjectProvider: () -> T): CollectingAssertionPlantNullable<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T> newFeatureAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newMultiAtriumErrorAdjuster(firstAdjuster: AtriumErrorAdjuster, secondAdjuster: AtriumErrorAdjuster, otherAdjusters: List<AtriumErrorAdjuster>): AtriumErrorAdjuster
abstract fun newNoOpAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade, atriumErrorAdjuster: AtriumErrorAdjuster): Reporter
abstract fun newRemoveAtriumFromAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newRemoveRunnerAtriumErrorAdjuster(): AtriumErrorAdjuster
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextNextLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType
object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType
object DefaultIndentAssertionGroupType : IndentAssertionGroupType
object DefaultListAssertionGroupType : ListAssertionGroupType
object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType
class DefaultTranslationsOf
class DeprecationTestEngine
enum class DescriptionAnyAssertion : StringBasedTranslatable
enum class DescriptionAnyAssertion : StringBasedTranslatable
enum class DescriptionBasic : StringBasedTranslatable
enum class DescriptionBasic : StringBasedTranslatable
enum class DescriptionBigDecimalAssertion : StringBasedTranslatable
enum class DescriptionBigDecimalAssertion : StringBasedTranslatable
enum class DescriptionCharSequenceAssertion : StringBasedTranslatable
enum class DescriptionCharSequenceAssertion : StringBasedTranslatable
enum class DescriptionCollectionAssertion : StringBasedTranslatable
enum class DescriptionCollectionAssertion : StringBasedTranslatable
enum class DescriptionComparableAssertion : StringBasedTranslatable
enum class DescriptionComparableAssertion : StringBasedTranslatable
enum class DescriptionFloatingPointAssertion : StringBasedTranslatable
enum class DescriptionFloatingPointAssertion : StringBasedTranslatable
enum class DescriptionIterableAssertion : StringBasedTranslatable
enum class DescriptionIterableAssertion : StringBasedTranslatable
enum class DescriptionListAssertion : StringBasedTranslatable
enum class DescriptionMapAssertion : StringBasedTranslatable
enum class DescriptionThrowableAssertion : StringBasedTranslatable
enum class DescriptionThrowableAssertion : StringBasedTranslatable
enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable
enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable
interface Descriptive
interface DescriptiveAssertion : Assertion
interface DescriptiveAssertionWithFailureHint
interface DoNotFilterAssertionGroupType : AssertionGroupType
class DownCaster<T : Any, TSub : T>
class Eintraege<in T : Any> : GroupWithoutNullableEntries<(Assert<T>) -> Unit>, GroupWithNullableEntries<(Assert<T>) -> Unit>, VarArgHelper<(Assert<T>) -> Unit>
class Eintrag<in T : Any> : GroupWithoutNullableEntries<(Assert<T>) -> Unit>, GroupWithNullableEntries<(Assert<T>) -> Unit>
object Empty
object Empty : Keyword
open class EmptyNameAndRepresentationAssertionGroup : AssertionGroup
class Entries<in T : Any, out A : (Assert<T>) -> Unit>
class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>, GroupWithNullableEntries<Assert<T>.() -> Unit>, VarArgHelper<Assert<T>.() -> Unit>
class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>, GroupWithNullableEntries<Assert<T>.() -> Unit>, VarArgHelper<Assert<T>.() -> Unit>
class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>, GroupWithNullableEntries<Assert<T>.() -> Unit>
class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>, GroupWithNullableEntries<Assert<T>.() -> Unit>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ExactlyCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class ExactlyCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>
object ExplainingAssertionCollectorOption
interface Explanatory
interface ExplanatoryAssertion : Assertion
class ExplanatoryAssertionGroup : EmptyNameAndRepresentationAssertionGroup
interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType
interface ExplanatoryAssertionGroupTypeOption
interface ExplanatoryGroup
class ExplanatoryTypeTransformationFailureHandler<T : Any, out TSub : T> : TypeTransformationFailureHandler<T, TSub>
interface FailureHandlerFactory
interface FeatureAssertionGroupType : AssertionGroupType
interface FeatureAssertions
Module Contents
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlant<R>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
object FeatureAssertionsBuilder : FeatureAssertions
Module Contents
inline val extractor: RepresentationOption
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
interface FeatureExtractor
Module Contents
interface Creator<TSubject, T : Any> : CreatorLike<TSubject, T, AssertionPlant<T>, CollectingAssertionPlant<T>>
interface CreatorLike<TSubject, T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>>
interface CreatorNullable<TSubject, T> : CreatorLike<TSubject, T, AssertionPlantNullable<T>, CollectingAssertionPlantNullable<T>>
data class ParameterObject<TSubject, T>
interface ParameterObjectOption
interface RepresentationOption
val builder: RepresentationOption
interface FeatureExtractorCreatorFactory
interface FixedClaimGroup
interface FixedClaimLikeGroup
expect interface FloatingPointAssertions : FloatingPointAssertionsCommon
expect object FloatingPointAssertionsBuilder : FloatingPointAssertions
interface FloatingPointAssertionsCommon
class ForgivingTest
interface Group<out T>
interface GroupWithNullableEntries<out T> : Group<T>
interface GroupWithoutNullableEntries<out T> : Group<T>
interface IAtriumFactory
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subject: T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subject: T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, vararg fallbackLocales: Locale): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
interface IgnoringCaseSearchBehaviour : SearchBehaviour
interface InAnyOrderOnlySearchBehaviour : SearchBehaviour
interface InAnyOrderSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
interface InOrderOnlySearchBehaviour : SearchBehaviour
interface InOrderSearchBehaviour : SearchBehaviour
class IndentAssertionGroup : EmptyNameAndRepresentationAssertionGroup
interface IndentAssertionGroupType : AssertionGroupType
data class Index
class InvisibleAssertionGroup : EmptyNameAndRepresentationAssertionGroup
object InvisibleAssertionGroupType : AssertionGroupType
interface IterableAssertions
object IterableAssertionsBuilder : IterableAssertions
interface IterableContains
Module Contents
interface Builder<out E, out T : Iterable<E>, out S : SearchBehaviour> : Builder<T, S>
interface Checker : Checker
interface CheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<T, S, Checker, Builder<E, T, S>>
interface Creator<in T : Iterable<*>, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour
interface IterableContains
interface IterableContainsAssertions
Module Contents
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion
object IterableContainsAssertionsBuilder : IterableContainsAssertions
Module Contents
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
inline val searchBehaviours: IterableContainsSearchBehaviourFactoryBuilder
inline fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion
class IterableContainsAtLeastChecker : IterableContainsChecker
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsAtLeastCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
class IterableContainsAtMostChecker : IterableContainsChecker
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<E, T, S>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsButAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
Module Contents
IterableContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilderBase<E, T, S>, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int
abstract class IterableContainsChecker : ContainsChecker, Checker
interface IterableContainsCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<E, T, S>>, CheckerOption<E, T, S>
class IterableContainsExactlyChecker : IterableContainsChecker
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsExactlyCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsInAnyOrderEntriesAssertionCreator<E : Any, T : Iterable<E?>> : ContainsAssertionCreator<T, AssertionPlant<E>.() -> Unit, Checker>, Creator<T, AssertionPlant<E>.() -> Unit>
class IterableContainsInAnyOrderObjectsAssertionCreator<S, T : Iterable<S>> : ContainsObjectsAssertionCreator<T, S, IterableContainsInAnyOrderSearchBehaviour, Checker>, Creator<T, S>
abstract class IterableContainsInAnyOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>
class IterableContainsInAnyOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>
class IterableContainsInAnyOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, E>
open class IterableContainsInAnyOrderOnlySearchBehaviour : SearchBehaviour, InAnyOrderOnlySearchBehaviour
open class IterableContainsInAnyOrderSearchBehaviour : SearchBehaviour, InAnyOrderSearchBehaviour
abstract class IterableContainsInOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>
class IterableContainsInOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>
class IterableContainsInOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, E>
open class IterableContainsInOrderOnlySearchBehaviour : SearchBehaviour, InOrderOnlySearchBehaviour
open class IterableContainsInOrderSearchBehaviour : SearchBehaviour, InOrderSearchBehaviour
class IterableContainsNoOpCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour
class IterableContainsNotChecker : Checker
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsNotCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
abstract class IterableContainsNotOrAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsNotSearchBehaviour : IterableContainsInAnyOrderSearchBehaviour, NotSearchBehaviour
object IterableContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory
Module Contents
inline fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): <ERROR CLASS>
data class Key<out K>
data class KeyNullableValue<out K, V : Any>
data class KeyNullableValue<out K, V : Any>
data class KeyNullableValue<out K, V : Any>
data class KeyValue<out K, V : Any>
data class KeyValue<out K, V : Any>
data class KeyValue<out K, V : Any>
interface Keyword
class LazyRepresentation
interface ListAssertionGroupType : AssertionGroupType
interface ListAssertions
object ListAssertionsBuilder : ListAssertions
interface ListGetNullableOption<E, T : List<E>>
interface ListGetOption<E : Any, T : List<E>>
data class Locale
interface LocaleOrderDecider
interface LocaleOrderDeciderOption
interface MapAssertions
Module Contents
abstract fun <K, V> contains(plant: AssertionPlant<Map<out K, V>>, keyValuePairs: List<<ERROR CLASS><K, V>>): Assertion
abstract fun <K> containsKey(plant: AssertionPlant<Map<out K, *>>, key: K): Assertion
abstract fun <K, V : Any> containsKeyWithValueAssertions(plant: AssertionPlant<Map<out K, V?>>, keyValues: List<<ERROR CLASS><K, Assert<V>.() -> Unit>>): Assertion
abstract fun <K> containsNotKey(plant: AssertionPlant<Map<out K, *>>, key: K): Assertion
abstract fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlant<V>
abstract fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
abstract fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlantNullable<V>
abstract fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun hasSize(plant: AssertionPlant<Map<*, *>>, size: Int): Assertion
abstract fun isEmpty(plant: AssertionPlant<Map<*, *>>): Assertion
abstract fun isNotEmpty(plant: AssertionPlant<Map<*, *>>): Assertion
abstract fun <K> keys(plant: AssertionPlant<Map<out K, *>>, assertionCreator: AssertionPlant<Set<K>>.() -> Unit): Assertion
abstract fun <V> values(plant: AssertionPlant<Map<*, V>>, assertionCreator: AssertionPlant<Collection<V>>.() -> Unit): Assertion
object MapAssertionsBuilder : MapAssertions
Module Contents
inline fun <K, V> contains(plant: AssertionPlant<Map<out K, V>>, keyValuePairs: List<<ERROR CLASS><K, V>>): Assertion
inline fun <K> containsKey(plant: AssertionPlant<Map<out K, *>>, key: K): <ERROR CLASS>
inline fun <K, V : Any> containsKeyWithValueAssertions(plant: AssertionPlant<Map<out K, V?>>, keyValues: List<<ERROR CLASS><K, Assert<V>.() -> Unit>>): <ERROR CLASS>
inline fun <K> containsNotKey(plant: AssertionPlant<Map<out K, *>>, key: K): <ERROR CLASS>
inline val entry: MapEntryAssertionsBuilder
inline fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K): <ERROR CLASS>
inline fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K, noinline assertionCreator: AssertionPlant<V>.() -> Unit): <ERROR CLASS>
inline fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K): <ERROR CLASS>
inline fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): <ERROR CLASS>
inline fun hasSize(plant: AssertionPlant<Map<*, *>>, size: Int): <ERROR CLASS>
inline fun isEmpty(plant: AssertionPlant<Map<*, *>>): <ERROR CLASS>
inline fun isNotEmpty(plant: AssertionPlant<Map<*, *>>): <ERROR CLASS>
inline fun <K> keys(plant: AssertionPlant<Map<out K, *>>, noinline assertionCreator: AssertionPlant<Set<K>>.() -> Unit): Assertion
inline fun <V> values(plant: AssertionPlant<Map<*, V>>, noinline assertionCreator: AssertionPlant<Collection<V>>.() -> Unit): Assertion
interface MapEntryAssertions
Module Contents
abstract fun <K : Any, V : Any> isKeyValue(plant: AssertionPlant<Entry<K, V>>, key: K, value: V): Assertion
abstract fun <K : Any> key(plant: AssertionPlant<Entry<K, *>>, assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
abstract fun <K> nullableKey(plant: AssertionPlant<Entry<K, *>>, assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
abstract fun <V> nullableValue(plant: AssertionPlant<Entry<*, V>>, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun <V : Any> value(plant: AssertionPlant<Entry<*, V>>, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
object MapEntryAssertionsBuilder : MapEntryAssertions
Module Contents
inline fun <K : Any, V : Any> isKeyValue(plant: AssertionPlant<Entry<K, V>>, key: K, value: V): Assertion
inline fun <K : Any> key(plant: AssertionPlant<Entry<K, *>>, noinline assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
inline fun <K> nullableKey(plant: AssertionPlant<Entry<K, *>>, noinline assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
inline fun <V> nullableValue(plant: AssertionPlant<Entry<*, V>>, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
inline fun <V : Any> value(plant: AssertionPlant<Entry<*, V>>, noinline assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
interface MapGetNullableOption<K, V, T : Map<out K, V>>
interface MapGetOption<K, V : Any, T : Map<out K, V>>
sealed class MaybeSubject<out T>
interface MethodCallFormatter
interface MultipleAdjustersOption : AtriumErrorAdjusterCommonOption<Unit>
@DslMarker annotation class MultipleAdjustersOptionMarker
class NoAdjustingReporterFactory : ReporterFactory
interface NoOpSearchBehaviour : SearchBehaviour
interface NoOpSearchBehaviour : SearchBehaviour
interface NonThrowingAssertionCollectorForExplanation : AssertionCollectorForExplanation
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
abstract class NotCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
abstract class NotCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class NotOrAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class NotOrAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>
interface NotSearchBehaviour : NoOpSearchBehaviour
interface NotSearchBehaviour : InAnyOrderSearchBehaviour
class NullableEintraege<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEintrag<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntries<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntries<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntry<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntry<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
data class NullableValue<T> : GroupWithNullableEntries<T>
data class NullableValue<T> : GroupWithNullableEntries<T>
class NullableValues<T> : GroupWithNullableEntries<T>
class NullableValues<T> : GroupWithNullableEntries<T>
data class NullableWert<T> : GroupWithNullableEntries<T>
class NullableWerte<T> : GroupWithNullableEntries<T>
interface ObjectFormatter
interface ObjectFormatterOption
class Objects<out T>
class Order<out T, out G : Group<T>>
interface PairAssertions
object PairAssertionsBuilder : PairAssertions
class Pairs<out K, out V> : VarArgHelper<<ERROR CLASS><K, V>>
interface PartiallyFixedClaimGroup
class PlantHasNoSubjectException : RuntimeException
class PleaseUseReplacementException : Exception
class PrefixFailingSummaryAssertion : BulletPointIdentifier
class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier
class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier
interface RawString
class RegexPatterns
class RegexPatterns : VarArgHelper<String>
interface Reporter
class ReporterBuilder
expect interface ReporterBuilder : ReporterBuilderCommon
interface ReporterBuilderCommon
interface ReporterBuilderFinalStep
interface ReporterFactory
interface ReporterOption
interface ReportingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseReportingAssertionPlant<T, AssertionPlant<T>>
interface ReportingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseReportingAssertionPlant<T, AssertionPlantNullable<T>>
object RootAssertionGroupType : AssertionGroupType
interface SearchBehaviourFactory
interface SearchBehaviourFactory
Module Contents
abstract fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InAnyOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): Builder<E, T, InAnyOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): Builder<E, T, InOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
data class StringBasedRawString : RawString
interface StringBasedTranslatable : Translatable
interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType
expect interface TextAssertionFormatterOption : TextAssertionFormatterOptionCommon
interface TextAssertionFormatterOptionCommon
interface ThrowableAssertions
object ThrowableAssertionsBuilder : ThrowableAssertions
interface ThrowableThrown
interface ThrowableThrown
class ThrowableThrownAssertionCreator<TExpected : Throwable> : Creator<TExpected>
interface ThrowableThrownAssertions
object ThrowableThrownAssertionsBuilder : ThrowableThrownAssertions
class ThrowableThrownBuilder : Builder
interface ThrowingAssertionCollectorForExplanation : AssertionCollectorForExplanation
interface Translatable
class TranslatableAsAbsentThrowableMessageProvider : AbsentThrowableMessageProvider
data class TranslatableBasedRawString : RawString
class TranslatableWithArgs : Translatable
interface TranslationSupplier
interface Translator
expect interface TranslatorOption : TranslatorOptionCommon
interface TranslatorOptionCommon
class TypeTransformer<T : Any, TSub : Any>
class Untranslatable : Translatable
class UsingDefaultTranslator : ArgumentsSupportingTranslator
data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>
data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>
class Values<out T>
class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>
class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>
interface VarArgHelper<out T>
object WarningAssertionGroupType : ExplanatoryAssertionGroupType
data class Wert<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>
class Werte<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>
interface WithTimesCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface WithTimesCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
object case
object case : Keyword
object contain
object contain : Keyword
object entries : Keyword
object group : Keyword
java.lang.StringBuilder
java.util.Locale
kotlin.Function0
kotlin.String
kotlin.Throwable
kotlin.reflect.KClass
object only
object only : Keyword
object order
object order : Keyword
package ch.tutteli.atrium
Module Contents
interface IAtriumFactory
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subject: T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T : Any> newFeatureAssertionChecker(subjectPlant: AssertionPlant<T>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade): Reporter
abstract fun newPropertiesBasedTranslationSupplier(): TranslationSupplier
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subject: T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
open fun <T> newReportingPlantNullable(assertionVerb: Translatable, subject: T, assertionChecker: AssertionChecker, nullRepresentation: Any): ReportingAssertionPlantNullable<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, vararg fallbackLocales: Locale): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<Class<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
package ch.tutteli.atrium.api.cc.de_CH
Module Contents
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> standardUebersetzungVon(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> wert(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> werte(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
class Eintraege<in T : Any> : GroupWithoutNullableEntries<(Assert<T>) -> Unit>, GroupWithNullableEntries<(Assert<T>) -> Unit>, VarArgHelper<(Assert<T>) -> Unit>
class Eintrag<in T : Any> : GroupWithoutNullableEntries<(Assert<T>) -> Unit>, GroupWithNullableEntries<(Assert<T>) -> Unit>
data class KeyNullableValue<out K, V : Any>
data class KeyValue<out K, V : Any>
class NullableEintraege<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEintrag<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
data class NullableWert<T> : GroupWithNullableEntries<T>
class NullableWerte<T> : GroupWithNullableEntries<T>
data class Wert<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>
class Werte<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>
fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.aberHoechstens(times: Int): ButAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.aberHoechstens(times: Int): ButAtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> aberHoechstens(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>> aberHoechstens(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
fun <E : Any, T : Iterable<E?>> Assert<T>.alle(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.alleDerNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <K, V> Assert<Map<out K, V>>.asEntries(): Assert<Set<Entry<K, V>>>
fun <K, V> Assert<Map<out K, V>>.asEntries(assertionCreator: Assert<Set<Entry<K, V>>>.() -> Unit): Assert<Set<Entry<K, V>>>
fun <E> Assert<Array<out E>>.asIterable(): Assert<Iterable<E>>
fun <E> Assert<Array<out E>>.asIterable(assertionCreator: Assert<Iterable<E>>.() -> Unit): Assert<Iterable<E>>
fun Assert<ByteArray>.asIterable(): Assert<Iterable<Byte>>
fun Assert<ByteArray>.asIterable(assertionCreator: Assert<Iterable<Byte>>.() -> Unit): Assert<Iterable<Byte>>
fun Assert<CharArray>.asIterable(): Assert<Iterable<Char>>
fun Assert<CharArray>.asIterable(assertionCreator: Assert<Iterable<Char>>.() -> Unit): Assert<Iterable<Char>>
fun Assert<ShortArray>.asIterable(): Assert<Iterable<Short>>
fun Assert<ShortArray>.asIterable(assertionCreator: Assert<Iterable<Short>>.() -> Unit): Assert<Iterable<Short>>
fun Assert<IntArray>.asIterable(): Assert<Iterable<Int>>
fun Assert<IntArray>.asIterable(assertionCreator: Assert<Iterable<Int>>.() -> Unit): Assert<Iterable<Int>>
fun Assert<LongArray>.asIterable(): Assert<Iterable<Long>>
fun Assert<LongArray>.asIterable(assertionCreator: Assert<Iterable<Long>>.() -> Unit): Assert<Iterable<Long>>
fun Assert<FloatArray>.asIterable(): Assert<Iterable<Float>>
fun Assert<FloatArray>.asIterable(assertionCreator: Assert<Iterable<Float>>.() -> Unit): Assert<Iterable<Float>>
fun Assert<DoubleArray>.asIterable(): Assert<Iterable<Double>>
fun Assert<DoubleArray>.asIterable(assertionCreator: Assert<Iterable<Double>>.() -> Unit): Assert<Iterable<Double>>
fun Assert<BooleanArray>.asIterable(): Assert<Iterable<Boolean>>
fun Assert<BooleanArray>.asIterable(assertionCreator: Assert<Iterable<Boolean>>.() -> Unit): Assert<Iterable<Boolean>>
fun <E> Assert<<ERROR CLASS><E>>.asIterable(): Assert<Iterable<E>>
fun <T : CharSequence> Assert<T>.beginntMit(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.beginntNichtMit(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.eintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.eintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.eintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintraege(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.eintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.eintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.eintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> eintrag(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endetMit(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endetNichtMit(expected: CharSequence): AssertionPlant<T>
val <T : CharSequence> Assert<T>.enthaelt: Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.enthaelt(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaelt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaelt(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaelt(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <K, V, T : Map<out K, V>> Assert<T>.enthaelt(entry: <ERROR CLASS><K, V>, vararg otherEntries: <ERROR CLASS><K, V>): AssertionPlant<T>
fun <K, V : Any, T : Map<out K, V?>> Assert<T>.enthaelt(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltExakt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltExakt(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltExakt(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <K> Assert<Map<out K, *>>.enthaeltKey(key: K): AssertionPlant<Map<out K, *>>
val <T : CharSequence> Assert<T>.enthaeltNicht: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.enthaeltNicht(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNicht(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltNichtDieStandardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <K> Assert<Map<out K, *>>.enthaeltNichtKey(key: K): AssertionPlant<Map<out K, *>>
fun <E, T : Iterable<E>> enthaeltNichtNonNullable(plant: Assert<T>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltNullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltNullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltNullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.enthaeltStandardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStrikt(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.enthaeltStrikt(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> enthaeltStriktNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStriktNullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.enthaeltStriktNullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltStriktNullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.enthaeltStriktNullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <K : Any> Assert<<ERROR CLASS><K, out <ERROR CLASS>>>.first: Assert<K>
fun <K : Any, V> Assert<<ERROR CLASS><K, V>>.first(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<<ERROR CLASS><K, V>>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.genau(times: Int): ExactlyCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.genau(times: Int): ExactlyCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> genau(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
fun <E, T : Iterable<E>> genau(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
fun <E : Any, T : List<E>> Assert<T>.get(index: Int): Assert<E>
fun <E : Any, T : List<E>> Assert<T>.get(index: Int, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> getEnthaelt(plant: Assert<T>): CharSequenceContainsBuilder<T, NoOpSearchBehaviour>
fun <T : CharSequence> getEnthaeltNicht(plant: Assert<T>): CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>
fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExistierend(key: K): Assert<V>
fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExistierend(key: K, assertionCreator: Assert<V>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> getIgnoriereGrossKleinschreibung(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> getIgnoriereGrossKleinschreibung(builder: CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> getInBeliebigerReihenfolge(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> getInGegebenerReihenfolge(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.gruppiert: <ERROR CLASS>
fun <T : Collection<*>> Assert<T>.hatDieGroesse(size: Int): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.hoechstens(times: Int): AtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.hoechstens(times: Int): AtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> hoechstens(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>> hoechstens(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
val <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoriereGrossKleinschreibung: Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoriereGrossKleinschreibung: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inBeliebigerReihenfolge: <ERROR CLASS>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inBeliebigerReihenfolge(firstGroup: Group<Assert<E>.() -> Unit>, secondGroup: Group<Assert<E>.() -> Unit>, vararg otherExpectedGroups: Group<Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> inBeliebigerReihenfolge(builder: Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithoutNullableEntries<E>, secondGroup: GroupWithoutNullableEntries<E>, vararg otherExpectedGroups: GroupWithoutNullableEntries<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> inBeliebigerReihenfolge(builder: Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithNullableEntries<E>, secondGroup: GroupWithNullableEntries<E>, vararg otherExpectedGroups: GroupWithNullableEntries<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> inBeliebigerReihenfolge(builder: Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithoutNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> inBeliebigerReihenfolge(builder: Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inGegebenerReihenfolge: <ERROR CLASS>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.innerhalb: <ERROR CLASS>
fun <E : Any, T : Iterable<E?>> Assert<T>.irgendEinNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.irgendEiner(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : Any> Assert<T>.ist(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.ist(expected: T?): Unit
fun <T> ist(plant: AssertionPlantNullable<T>, void: Void?): Unit
inline fun <reified TSub : Any> Assert<Any>.istEin(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun Assert<Boolean>.istFalse(): AssertionPlant<Boolean>
fun <T : BigDecimal> Assert<T>.istGleichInklusiveScale(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istGroesserAls(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istGroesserOderGleich(expected: T): AssertionPlant<T>
fun <K : Any, V : Any> Assert<Entry<K, V>>.istKeyValue(key: K, value: V): Assert<Entry<K, V>>
fun <T : Comparable<T>> Assert<T>.istKleinerAls(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.istKleinerOderGleich(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istLeer(): AssertionPlant<T>
fun Assert<Float>.istMitFehlerToleranz(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.istMitFehlerToleranz(expected: Double, tolerance: Double): AssertionPlant<Double>
fun <T : BigDecimal> Assert<T>.istMitFehlerToleranz(expected: T, tolerance: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istNicht(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istNichtBlank(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.istNichtGleichInklusiveScale(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.istNichtLeer(): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.istNichtNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
infix fun <T : BigDecimal> AssertionPlantNullable<T?>.istNichtNullAber(expected: T): Nothing
fun <T : BigDecimal> Assert<T>.istNichtNumerischGleichWie(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istNichtSelbeInstanzWie(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.istNull(): Unit
inline fun <reified T : Any> AssertionPlantNullable<T?>.istNullWennNullGegebenSonst(noinline assertionCreatorOrNull: Assert<T>.() -> Unit): Unit
fun <T : BigDecimal> Assert<T>.istNumerischGleichWie(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.istSelbeInstanzWie(expected: T): AssertionPlant<T>
fun Assert<Boolean>.istTrue(): AssertionPlant<Boolean>
fun <E : Any, T : Iterable<E?>> Assert<T>.keiner(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.keinerDerNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
val <K : Any> Assert<Entry<K, *>>.key: Assert<K>
fun <K : Any, V> Assert<Entry<K, V>>.key(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Entry<K, V>>
val <K, V> Assert<Map<out K, V>>.keys: Assert<Set<K>>
fun <K, V, T : Map<out K, V>> Assert<T>.keys(assertionCreator: Assert<Set<K>>.() -> Unit): AssertionPlant<T>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : Throwable> Assert<T>.messageEnthaelt(expected: Any, vararg otherExpected: Any): Unit
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.nichtOderHoechstens(times: Int): NotOrAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.nichtOderHoechstens(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> nichtOderHoechstens(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>> nichtOderHoechstens(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintraege(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEintraege(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEintrag(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEintrag(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableWert(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableWerte(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.nur: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.nur: <ERROR CLASS>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.objekt(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekt(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.objekte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objekte(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.rueckgabewertVon(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.rueckgabewertVon(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
val <V : Any> Assert<<ERROR CLASS><out <ERROR CLASS>, V>>.second: Assert<V>
fun <K, V : Any> Assert<<ERROR CLASS><K, V>>.second(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<<ERROR CLASS><K, V>>
val Assert<Collection<*>>.size: Assert<Int>
fun <E, T : Collection<E>> Assert<T>.size(assertionCreator: Assert<Int>.() -> Unit): Assert<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.standardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.standardUebersetzungVon(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
val <T : Any> Assert<T>.und: Assert<T>
infix fun <T : Any> AssertionPlant<T>.und(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
val <V : Any> Assert<Entry<*, V>>.value: Assert<V>
fun <K, V : Any> Assert<Entry<K, V>>.value(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Entry<K, V>>
val <K, V> Assert<Map<out K, V>>.values: Assert<Collection<V>>
fun <K, V, T : Map<out K, V>> Assert<T>.values(assertionCreator: Assert<Collection<V>>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.wert(expected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.wert(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> wert(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.werte(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.werte(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> werte(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
inline fun <reified TExpected : Throwable> Builder.wirft(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
inline fun <reified TExpected : Throwable> Builder.wirft(): Unit
fun Builder.wirftNichts(): Unit
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.zumindest(times: Int): AtLeastCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.zumindest(times: Int): AtLeastCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> zumindest(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
fun <E, T : Iterable<E>> zumindest(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
package ch.tutteli.atrium.api.cc.de_CH.assertions.charsequence.contains.builders
Module Contents
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
package ch.tutteli.atrium.api.cc.de_CH.assertions.iterable.contains.builders
Module Contents
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
package ch.tutteli.atrium.api.cc.de_CH.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
package ch.tutteli.atrium.api.cc.de_CH.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
package ch.tutteli.atrium.api.cc.en_GB
Module Contents
class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>, GroupWithNullableEntries<Assert<T>.() -> Unit>, VarArgHelper<Assert<T>.() -> Unit>
class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>, GroupWithNullableEntries<Assert<T>.() -> Unit>
data class KeyNullableValue<out K, V : Any>
data class KeyValue<out K, V : Any>
class NullableEntries<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntry<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
data class NullableValue<T> : GroupWithNullableEntries<T>
class NullableValues<T> : GroupWithNullableEntries<T>
data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>
class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.all(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.allOfNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
val <T : Any> AssertionPlant<T>.and: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.any(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.anyOfNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <K, V> Assert<Map<K, V>>.asEntries(): Assert<Set<Entry<K, V>>>
fun <K, V> Assert<Map<K, V>>.asEntries(assertionCreator: Assert<Set<Entry<K, V>>>.() -> Unit): Assert<Set<Entry<K, V>>>
fun <E> Assert<Array<out E>>.asIterable(): Assert<Iterable<E>>
fun <E> Assert<Array<out E>>.asIterable(assertionCreator: Assert<Iterable<E>>.() -> Unit): Assert<Iterable<E>>
fun Assert<ByteArray>.asIterable(): Assert<Iterable<Byte>>
fun Assert<ByteArray>.asIterable(assertionCreator: Assert<Iterable<Byte>>.() -> Unit): Assert<Iterable<Byte>>
fun Assert<CharArray>.asIterable(): Assert<Iterable<Char>>
fun Assert<CharArray>.asIterable(assertionCreator: Assert<Iterable<Char>>.() -> Unit): Assert<Iterable<Char>>
fun Assert<ShortArray>.asIterable(): Assert<Iterable<Short>>
fun Assert<ShortArray>.asIterable(assertionCreator: Assert<Iterable<Short>>.() -> Unit): Assert<Iterable<Short>>
fun Assert<IntArray>.asIterable(): Assert<Iterable<Int>>
fun Assert<IntArray>.asIterable(assertionCreator: Assert<Iterable<Int>>.() -> Unit): Assert<Iterable<Int>>
fun Assert<LongArray>.asIterable(): Assert<Iterable<Long>>
fun Assert<LongArray>.asIterable(assertionCreator: Assert<Iterable<Long>>.() -> Unit): Assert<Iterable<Long>>
fun Assert<FloatArray>.asIterable(): Assert<Iterable<Float>>
fun Assert<FloatArray>.asIterable(assertionCreator: Assert<Iterable<Float>>.() -> Unit): Assert<Iterable<Float>>
fun Assert<DoubleArray>.asIterable(): Assert<Iterable<Double>>
fun Assert<DoubleArray>.asIterable(assertionCreator: Assert<Iterable<Double>>.() -> Unit): Assert<Iterable<Double>>
fun Assert<BooleanArray>.asIterable(): Assert<Iterable<Boolean>>
fun Assert<BooleanArray>.asIterable(assertionCreator: Assert<Iterable<Boolean>>.() -> Unit): Assert<Iterable<Boolean>>
fun <E> Assert<<ERROR CLASS><E>>.asIterable(): Assert<Iterable<E>>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
val <T : CharSequence> Assert<T>.contains: Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.contains(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.contains(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.contains(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.contains(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <K, V, T : Map<out K, V>> Assert<T>.contains(keyValuePair: <ERROR CLASS><K, V>, vararg otherPairs: <ERROR CLASS><K, V>): AssertionPlant<T>
fun <K, V : Any, T : Map<out K, V?>> Assert<T>.contains(keyValue: KeyValue<K, V>, vararg otherKeyValues: KeyValue<K, V>): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsExactly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <K> Assert<Map<out K, *>>.containsKey(key: K): AssertionPlant<Map<out K, *>>
val <T : CharSequence> Assert<T>.containsNot: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.containsNot(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <K> Assert<Map<out K, *>>.containsNotKey(key: K): AssertionPlant<Map<out K, *>>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsNullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictlyNullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictlyNullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.entries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.entries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
val <K : Any> Assert<<ERROR CLASS><K, out <ERROR CLASS>>>.first: Assert<K>
fun <K : Any, V> Assert<<ERROR CLASS><K, V>>.first(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<<ERROR CLASS><K, V>>
fun <E : Any, T : List<E>> Assert<T>.get(index: Int): Assert<E>
fun <E : Any, T : List<E>> Assert<T>.get(index: Int, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: K): Assert<V>
fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: K, assertionCreator: Assert<V>.() -> Unit): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.grouped: <ERROR CLASS>
fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
val <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoringCase: Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoringCase: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<E>, secondGroup: Group<E>, vararg otherExpectedGroups: Group<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAnyOrder(firstGroup: Group<Assert<E>.() -> Unit>, secondGroup: Group<Assert<E>.() -> Unit>, vararg otherExpectedGroups: Group<Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithoutNullableEntries<E>, secondGroup: GroupWithoutNullableEntries<E>, vararg otherExpectedGroups: GroupWithoutNullableEntries<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithNullableEntries<E>, secondGroup: GroupWithNullableEntries<E>, vararg otherExpectedGroups: GroupWithNullableEntries<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithoutNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithoutNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> inAnyOrder(builder: Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>, firstGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, secondGroup: GroupWithNullableEntries<Assert<E>.() -> Unit>, vararg otherExpectedGroups: GroupWithNullableEntries<Assert<E>.() -> Unit>): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAnyOrder: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inOrder: <ERROR CLASS>
inline fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> Assert<T>.isEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
fun <K : Any, V : Any> Assert<Entry<K, V>>.isKeyValue(key: K, value: V): Assert<Entry<K, V>>
fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotBlank(): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isNotSameAs(expected: T): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isSameAs(expected: T): AssertionPlant<T>
val <K : Any> Assert<Entry<K, *>>.key: Assert<K>
fun <K : Any, V> Assert<Entry<K, V>>.key(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Entry<K, V>>
val <K> Assert<Map<K, *>>.keys: Assert<Set<K>>
fun <K, V, T : Map<K, V>> Assert<T>.keys(assertionCreator: Assert<Set<K>>.() -> Unit): AssertionPlant<T>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : Throwable> Assert<T>.messageContains(expected: Any, vararg otherExpected: Any): Unit
fun <E : Any, T : Iterable<E?>> Assert<T>.none(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Assert<T>.noneOfNullable(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <T : BigDecimal> AssertionPlantNullable<T?>.notToBeNullBut(expected: T): Nothing
fun Builder.notToThrow(): Unit
fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntries(assertionCreatorOrNull: Assert<E>.() -> Unit, vararg otherAssertionCreatorsOrNulls: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValues(expectedOrNull: E, vararg otherExpectedOrNulls: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.only: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.only: <ERROR CLASS>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
val <V : Any> Assert<<ERROR CLASS><out <ERROR CLASS>, V>>.second: Assert<V>
fun <K, V : Any> Assert<<ERROR CLASS><K, V>>.second(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<<ERROR CLASS><K, V>>
val Assert<Collection<*>>.size: Assert<Int>
fun <E, T : Collection<E>> Assert<T>.size(assertionCreator: Assert<Int>.() -> Unit): Assert<T>
fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.toBe(expected: T?): Unit
fun <T> toBe(plant: AssertionPlantNullable<T>, void: Void?): Unit
inline fun <reified T : Any> AssertionPlantNullable<T?>.toBeNullIfNullGivenElse(noinline assertionCreatorOrNull: Assert<T>.() -> Unit): Unit
fun Assert<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): AssertionPlant<Double>
fun Assert<BigDecimal>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): AssertionPlant<BigDecimal>
inline fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <K, V : Any> Assert<Entry<K, V>>.value(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Entry<K, V>>
val <V : Any> Assert<Entry<*, V>>.value: Assert<V>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <K, V, T : Map<K, V>> Assert<T>.values(assertionCreator: Assert<Collection<V>>.() -> Unit): AssertionPlant<T>
val <V> Assert<Map<*, V>>.values: Assert<Collection<V>>
val <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within: <ERROR CLASS>
package ch.tutteli.atrium.api.cc.en_GB.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
package ch.tutteli.atrium.api.cc.en_GB.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
package ch.tutteli.atrium.api.cc.en_UK
Module Contents
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> values(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any, vararg otherExpected: Any): AssertionPlant<T>
val <T : Any> AssertionPlant<T>.and: AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atLeast(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atLeast(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> butAtMost(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> butAtMost(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
val <T : CharSequence> Assert<T>.contains: Builder<T, NoOpSearchBehaviour>
fun <T : CharSequence> Assert<T>.contains(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.contains(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsDefaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
val <T : CharSequence> Assert<T>.containsNot: NotCheckerOption<T, NotSearchBehaviour>
fun <T : CharSequence> Assert<T>.containsNot(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsNotDefaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.containsRegex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNulllable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.defaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.defaultTranslationOf(expected: Translatable, vararg otherExpected: Translatable): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entries(assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entries(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> exactly(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> exactly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
fun <T : CharSequence> getContains(plant: Assert<T>): CharSequenceContainsBuilder<T, NoOpSearchBehaviour>
fun <T : CharSequence> getContainsNot(plant: Assert<T>): CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>
fun <T : CharSequence> getIgnoringCase(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> getIgnoringCase(builder: CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
fun <E, T : Iterable<E>> getInAnyOrder(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> getInOrder(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
val <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoringCase: Builder<T, IgnoringCaseSearchBehaviour>
val <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoringCase: NotCheckerOption<T, IgnoringCaseSearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAnyOrder: <ERROR CLASS>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
val <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inOrder: <ERROR CLASS>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
inline fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> Assert<T>.isEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
fun Assert<Boolean>.isFalse(): AssertionPlant<Boolean>
fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.isNotEmpty(): AssertionPlant<T>
fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
inline fun <reified T : Any> AssertionPlantNullable<T?>.isNotNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isNotSame(expected: T): AssertionPlant<T>
fun <T> AssertionPlantNullable<T>.isNull(): Unit
fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
fun <T : Any> Assert<T>.isSame(expected: T): AssertionPlant<T>
fun Assert<Boolean>.isTrue(): AssertionPlant<Boolean>
fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> notOrAtMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> notOrAtMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit, vararg otherAssertionCreators: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValues(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.objects(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> objects(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
val <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.only: <ERROR CLASS>
val <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.only: <ERROR CLASS>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String, vararg otherPatterns: String): AssertionPlant<T>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
fun Assert<Float>.toBeWithErrorTolerance(expected: Float, tolerance: Float): AssertionPlant<Float>
fun Assert<Double>.toBeWithErrorTolerance(expected: Double, tolerance: Double): AssertionPlant<Double>
fun Assert<BigDecimal>.toBeWithErrorTolerance(expected: BigDecimal, tolerance: BigDecimal): AssertionPlant<BigDecimal>
inline fun <reified TExpected : Throwable> Builder.toThrow(): Unit
inline fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.values(expected: Any, vararg otherExpected: Any): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.values(expected: E, vararg otherExpected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> values(checkerBuilder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E, vararg otherExpected: E): AssertionPlant<T>
package ch.tutteli.atrium.api.cc.en_UK.assertions.charsequence.contains.builders
Module Contents
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
package ch.tutteli.atrium.api.cc.en_UK.assertions.iterable.contains.builders
Module Contents
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
package ch.tutteli.atrium.api.cc.en_UK.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>
package ch.tutteli.atrium.api.cc.en_UK.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>
package ch.tutteli.atrium.api.cc.infix.en_GB
Module Contents
class All<out T> : VarArgHelper<T>
class Entries<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>, GroupWithNullableEntries<Assert<T>.() -> Unit>, VarArgHelper<Assert<T>.() -> Unit>
class Entry<in T : Any> : GroupWithoutNullableEntries<Assert<T>.() -> Unit>, GroupWithNullableEntries<Assert<T>.() -> Unit>
data class Index
data class Key<out K>
data class KeyNullableValue<out K, V : Any>
data class KeyValue<out K, V : Any>
class NullableEntries<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
class NullableEntry<T : Any> : GroupWithNullableEntries<Assert<T>.() -> Unit>
data class NullableValue<T> : GroupWithNullableEntries<T>
class NullableValues<T> : GroupWithNullableEntries<T>
class Order<out T, out G : Group<T>>
class Pairs<out K, out V> : VarArgHelper<<ERROR CLASS><K, V>>
class RegexPatterns : VarArgHelper<String>
data class Value<out T> : GroupWithNullableEntries<T>, GroupWithoutNullableEntries<T>
class Values<out T> : GroupWithoutNullableEntries<T>, GroupWithNullableEntries<T>, VarArgHelper<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.all(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.all(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.and(only: only): <ERROR CLASS>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.any(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.any(nullableEntry: NullableEntry<E>): AssertionPlant<T>
fun <K, V> Assert<Map<out K, V>>.asEntries(): Assert<Set<Entry<K, V>>>
infix fun <K, V> Assert<Map<out K, V>>.asEntries(assertionCreator: Assert<Set<Entry<K, V>>>.() -> Unit): Assert<Set<Entry<K, V>>>
fun <E> Assert<Array<out E>>.asIterable(): Assert<Iterable<E>>
infix fun <E> Assert<Array<out E>>.asIterable(assertionCreator: Assert<Iterable<E>>.() -> Unit): Assert<Iterable<E>>
fun Assert<ByteArray>.asIterable(): Assert<Iterable<Byte>>
infix fun Assert<ByteArray>.asIterable(assertionCreator: Assert<Iterable<Byte>>.() -> Unit): Assert<Iterable<Byte>>
fun Assert<CharArray>.asIterable(): Assert<Iterable<Char>>
infix fun Assert<CharArray>.asIterable(assertionCreator: Assert<Iterable<Char>>.() -> Unit): Assert<Iterable<Char>>
fun Assert<ShortArray>.asIterable(): Assert<Iterable<Short>>
infix fun Assert<ShortArray>.asIterable(assertionCreator: Assert<Iterable<Short>>.() -> Unit): Assert<Iterable<Short>>
fun Assert<IntArray>.asIterable(): Assert<Iterable<Int>>
infix fun Assert<IntArray>.asIterable(assertionCreator: Assert<Iterable<Int>>.() -> Unit): Assert<Iterable<Int>>
fun Assert<LongArray>.asIterable(): Assert<Iterable<Long>>
infix fun Assert<LongArray>.asIterable(assertionCreator: Assert<Iterable<Long>>.() -> Unit): Assert<Iterable<Long>>
fun Assert<FloatArray>.asIterable(): Assert<Iterable<Float>>
infix fun Assert<FloatArray>.asIterable(assertionCreator: Assert<Iterable<Float>>.() -> Unit): Assert<Iterable<Float>>
fun Assert<DoubleArray>.asIterable(): Assert<Iterable<Double>>
infix fun Assert<DoubleArray>.asIterable(assertionCreator: Assert<Iterable<Double>>.() -> Unit): Assert<Iterable<Double>>
fun Assert<BooleanArray>.asIterable(): Assert<Iterable<Boolean>>
infix fun Assert<BooleanArray>.asIterable(assertionCreator: Assert<Iterable<Boolean>>.() -> Unit): Assert<Iterable<Boolean>>
fun <E> Assert<<ERROR CLASS><E>>.asIterable(): Assert<Iterable<E>>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): <ERROR CLASS>
infix fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
infix fun <T : CharSequence> Assert<T>.contains(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(expected: E): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Assert<T>.contains(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(entries: Entries<E>): AssertionPlant<T>
infix fun <K, V, T : Map<out K, V>> Assert<T>.contains(keyValuePair: <ERROR CLASS><K, V>): <ERROR CLASS>
infix fun <K, V, T : Map<out K, V>> Assert<T>.contains(keyValuePairs: Pairs<K, V>): AssertionPlant<T>
infix fun <K, V : Any, T : Map<out K, V?>> Assert<T>.contains(keyValue: KeyValue<K, V>): AssertionPlant<T>
infix fun <K, V : Any, T : Map<out K, V?>> Assert<T>.contains(keyValues: All<KeyValue<K, V>>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(nullableValue: NullableValue<E>): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Assert<T>.contains(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.contains(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsExactly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsExactly(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsExactly(entries: Entries<E>): AssertionPlant<T>
infix fun <K> Assert<Map<out K, *>>.containsKey(key: K): AssertionPlant<Map<out K, *>>
infix fun <T : CharSequence> Assert<T>.containsNot(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(values: Values<Any>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(values: Values<E>): AssertionPlant<T>
infix fun <K> Assert<Map<out K, *>>.containsNotKey(key: K): AssertionPlant<Map<out K, *>>
infix fun <T : CharSequence> Assert<T>.containsRegex(pattern: String): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: NullableValue<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictly(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(entries: Entries<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.containsStrictly(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.entry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.entry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
val <K : Any> Assert<<ERROR CLASS><K, out <ERROR CLASS>>>.first: Assert<K>
infix fun <K : Any, V> Assert<<ERROR CLASS><K, V>>.first(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<<ERROR CLASS><K, V>>
infix fun <E : Any, T : List<E>> Assert<T>.get(index: Int): AssertionPlant<E>
infix fun <E : Any, T : List<E>> Assert<T>.get(index: Index): ListGetOption<E, T>
infix fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: K): Assert<V>
infix fun <K, V : Any, T : Map<out K, V>> Assert<T>.getExisting(key: Key<K>): MapGetOption<K, V, T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.grouped(entries: entries): <ERROR CLASS>
infix fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoring(case: case): Builder<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<E, Group<E>>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>.inAny(order: Order<Assert<E>.() -> Unit, Group<Assert<E>.() -> Unit>>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): <ERROR CLASS>
fun <E, T : Iterable<E>> inAny(builder: Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>, order: Order<E, GroupWithNullableEntries<E>>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> inAny(builder: Builder<E?, T, InOrderOnlyGroupedWithinSearchBehaviour>, order: Order<Assert<E>.() -> Unit, GroupWithNullableEntries<Assert<E>.() -> Unit>>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): <ERROR CLASS>
inline infix fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
infix fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
infix fun <K : Any, V : Any> Assert<Entry<K, V>>.isKeyValue(keyValuePair: <ERROR CLASS><K, V>): Assert<Entry<K, V>>
infix fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isNotSameAs(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isSameAs(expected: T): AssertionPlant<T>
val <K : Any> Assert<Entry<K, *>>.key: Assert<K>
infix fun <K : Any, V> Assert<Entry<K, V>>.key(assertionCreator: Assert<K>.() -> Unit): AssertionPlant<Entry<K, V>>
val <K, V> Assert<Map<out K, V>>.keys: Assert<Set<K>>
infix fun <K, V, T : Map<out K, V>> Assert<T>.keys(assertionCreator: Assert<Set<K>>.() -> Unit): AssertionPlant<T>
infix fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
infix fun <T : Throwable> Assert<T>.messageContains(expected: Any): Unit
infix fun <T : Throwable> Assert<T>.messageContains(values: Values<Any>): Unit
infix fun <E : Any, T : Iterable<E?>> Assert<T>.none(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Assert<T>.none(nullableEntry: NullableEntry<E>): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
infix fun <T : CharSequence> Assert<T>.notTo(contain: contain): NotCheckerOption<T, NotSearchBehaviour>
infix fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.notToBe(keyword: Keyword): Nothing
infix fun <T : CharSequence> Assert<T>.notToBe(Empty: Empty): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.notToBe(Blank: Blank): AssertionPlant<T>
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
infix fun <T : BigDecimal> AssertionPlantNullable<T?>.notToBeNullBut(expected: T): Nothing
infix fun <T : Any> AssertionPlantNullable<T>.notToBeNullBut(keyword: Keyword): Nothing
fun Builder.notToThrow(): Unit
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.nullableEntry(assertionCreatorOrNull: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.nullableValue(expectedOrNull: E): AssertionPlant<T>
inline val <T : Any> Assert<T>.o: Assert<T>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> CollectingAssertionPlant<T>.property(property: KProperty0<TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty1<T, TProperty>, assertionCreator: Assert<TProperty>.() -> Unit): AssertionPlant<TProperty>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction0<R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, R : Any> Assert<T>.returnValueOf(method: KFunction1<T, R>, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction1<T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, R : Any> Assert<T>.returnValueOf(method: KFunction2<T, T1, R>, arg1: T1, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, R : Any> Assert<T>.returnValueOf(method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, R : Any> Assert<T>.returnValueOf(method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, R : Any> Assert<T>.returnValueOf(method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> CollectingAssertionPlant<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
fun <T : Any, T1, T2, T3, T4, T5, R : Any> Assert<T>.returnValueOf(method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: Assert<R>.() -> Unit): AssertionPlant<R>
val <V : Any> Assert<<ERROR CLASS><out <ERROR CLASS>, V>>.second: Assert<V>
infix fun <K, V : Any> Assert<<ERROR CLASS><K, V>>.second(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<<ERROR CLASS><K, V>>
val Assert<Collection<*>>.size: Assert<Int>
infix fun <E, T : Collection<E>> Assert<T>.size(assertionCreator: Assert<Int>.() -> Unit): Assert<T>
infix fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> CheckerOption<E?, T, InAnyOrderSearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InAnyOrderOnlySearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(nullableValues: NullableValues<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E?>> Builder<E?, T, InOrderOnlySearchBehaviour>.the(nullableEntries: NullableEntries<E>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.to(contain: contain): Builder<T, NoOpSearchBehaviour>
infix fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.toBe(keyword: Keyword): Nothing
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.toBe(expected: T?): Unit
infix fun <T : CharSequence> Assert<T>.toBe(Empty: Empty): AssertionPlant<T>
fun <T> toBe(plant: AssertionPlantNullable<T>, void: Void?): Unit
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.toBeNullIfNullGivenElse(noinline assertionCreatorOrNull: Assert<T>.() -> Unit): Unit
inline infix fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
infix fun <K, V : Any> Assert<Entry<K, V>>.value(assertionCreator: Assert<V>.() -> Unit): AssertionPlant<Entry<K, V>>
val <V : Any> Assert<Entry<*, V>>.value: Assert<V>
val <K, V> Assert<Map<out K, V>>.values: Assert<Collection<V>>
infix fun <K, V, T : Map<out K, V>> Assert<T>.values(assertionCreator: Assert<Collection<V>>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlyGroupedSearchBehaviour>.within(group: group): <ERROR CLASS>
package ch.tutteli.atrium.api.cc.infix.en_GB.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
package ch.tutteli.atrium.api.cc.infix.en_GB.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
package ch.tutteli.atrium.api.cc.infix.en_GB.creating.list.get.builders
package ch.tutteli.atrium.api.cc.infix.en_GB.creating.map.get.builders
package ch.tutteli.atrium.api.cc.infix.en_GB.keywords
package ch.tutteli.atrium.api.cc.infix.en_UK
Module Contents
object CharSequenceContainsSearchersKt
Module Contents
fun <T : CharSequence> defaultTranslationOf(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatable: Translatable): AssertionPlant<T>
fun <T : CharSequence> regex(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, pattern: String): AssertionPlant<T>
fun <T : CharSequence> regexIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
fun <T : CharSequence> the(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, patterns: RegexPatterns): AssertionPlant<T>
fun <T : CharSequence> value(checkerBuilder: CharSequenceContainsCheckerBuilder<T, NoOpSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valueIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, expected: Any): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, values: Values<Any>): AssertionPlant<T>
fun <T : CharSequence> valuesIgnoringCase(checkerBuilder: CharSequenceContainsCheckerBuilder<T, IgnoringCaseSearchBehaviour>, translatables: DefaultTranslationsOf): AssertionPlant<T>
class DefaultTranslationsOf
object Empty
class Entries<in T : Any, out A : (Assert<T>) -> Unit>
class Objects<out T>
class RegexPatterns
class Values<out T>
infix fun <T : Any> AssertionPlant<T>.and(assertionCreator: Assert<T>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atLeast(times: Int): AtLeastCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atLeast(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtLeastCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atLeast(times: Int): AtLeastCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atLeast(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtLeastCheckerBuilder<E, T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.atMost(times: Int): AtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> atMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.atMost(times: Int): AtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> atMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsAtMostCheckerBuilder<E, T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderSearchBehaviour>.but(only: only): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderSearchBehaviour>.but(only: only): <ERROR CLASS>
infix fun <T : CharSequence, S : SearchBehaviour> AtLeastCheckerOption<T, S>.butAtMost(times: Int): ButAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> butAtMost(checkerBuilder: CharSequenceContainsAtLeastCheckerBuilder<T, S>, times: Int): CharSequenceContainsButAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> AtLeastCheckerOption<E, T, S>.butAtMost(times: Int): ButAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> butAtMost(checkerBuilder: IterableContainsAtLeastCheckerBuilder<E, T>, times: Int): IterableContainsButAtMostCheckerBuilder<E, T>
object case
object contain
infix fun <T : CharSequence> Assert<T>.contains(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(defaultTranslationOf: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.contains(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(expected: E): <ERROR CLASS>
infix fun <E, T : Iterable<E>> Assert<T>.contains(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.contains(objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.contains(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsDefaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsNot(defaultTranslationsOf: DefaultTranslationsOf): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsNot(objects: Objects<E>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsNullable(plant: Assert<T>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.containsRegex(pattern: String): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Assert<T>.containsStrictly(objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Assert<T>.containsStrictly(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> containsStrictlyNullable(plant: Assert<T>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.defaultTranslationOf(translatable: Translatable): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.endsWith(expected: CharSequence): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.entry(assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> entry(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.exactly(times: Int): ExactlyCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> exactly(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsExactlyCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.exactly(times: Int): ExactlyCheckerOption<E, T, S>
fun <E, T : Iterable<E>> exactly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsExactlyCheckerBuilder<E, T>
infix fun <T : Collection<*>> Assert<T>.hasSize(size: Int): AssertionPlant<T>
infix fun <T : CharSequence> Builder<T, NoOpSearchBehaviour>.ignoring(case: case): Builder<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> ignoring(builder: CharSequenceContainsBuilder<T, NoOpSearchBehaviour>, case: case): CharSequenceContainsBuilder<T, IgnoringCaseSearchBehaviour>
infix fun <T : CharSequence> NotCheckerOption<T, NotSearchBehaviour>.ignoring(case: case): NotCheckerOption<T, IgnoringCaseSearchBehaviour>
fun <T : CharSequence> CharSequenceContainsNotCheckerBuilder<T, NotSearchBehaviour>.ignoring(case: case): CharSequenceContainsNotCheckerBuilder<T, IgnoringCaseSearchBehaviour>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inAny(order: order): <ERROR CLASS>
fun <E, T : Iterable<E>> inAny(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> inAnyOrderOnly(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>
infix fun <E, T : Iterable<E>> Builder<E, T, NoOpSearchBehaviour>.inGiven(order: order): <ERROR CLASS>
fun <E, T : Iterable<E>> inGiven(builder: IterableContainsBuilder<E, T, NoOpSearchBehaviour>, order: order): IterableContainsBuilder<E, T, InOrderSearchBehaviour>
fun <E, T : Iterable<E>> inOrderOnly(builder: IterableContainsBuilder<E, T, InOrderSearchBehaviour>, only: only): IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>
inline infix fun <reified TSub : Any> Assert<Any>.isA(noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
infix fun <T : BigDecimal> Assert<T>.isEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isGreaterThan(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessOrEquals(expected: T): AssertionPlant<T>
infix fun <T : Comparable<T>> Assert<T>.isLessThan(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotEqualIncludingScale(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNotNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isNotSame(expected: T): AssertionPlant<T>
infix fun <T : BigDecimal> Assert<T>.isNumericallyEqualTo(expected: T): AssertionPlant<T>
infix fun <T : Any> Assert<T>.isSame(expected: T): AssertionPlant<T>
infix fun <T : Throwable> Assert<T>.message(assertionCreator: Assert<String>.() -> Unit): Unit
infix fun <T : CharSequence, S : SearchBehaviour> Builder<T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<T, S>
fun <T : CharSequence, S : SearchBehaviour> notOrAtMost(builder: CharSequenceContainsBuilder<T, S>, times: Int): CharSequenceContainsNotOrAtMostCheckerBuilder<T, S>
infix fun <E, T : Iterable<E>, S : InAnyOrderSearchBehaviour> Builder<E, T, S>.notOrAtMost(times: Int): NotOrAtMostCheckerOption<E, T, S>
fun <E, T : Iterable<E>> notOrAtMost(builder: IterableContainsBuilder<E, T, InAnyOrderSearchBehaviour>, times: Int): IterableContainsNotOrAtMostCheckerBuilder<E, T>
infix fun <T : CharSequence> Assert<T>.notTo(contain: contain): NotCheckerOption<T, NotSearchBehaviour>
infix fun <T : Any> Assert<T>.notToBe(expected: T): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.notToBe(onlyEmptyAllowed: Empty): AssertionPlant<T>
inline infix fun <reified T : Any> AssertionPlantNullable<T?>.notToBeNull(noinline assertionCreator: Assert<T>.() -> Unit): Unit
fun <E : Any, T : Iterable<E?>> nullableEntries(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntries(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(checkerBuilder: IterableContainsCheckerBuilder<E?, T, InAnyOrderSearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
fun <E : Any, T : Iterable<E?>> nullableEntry(builder: IterableContainsBuilder<E?, T, InOrderOnlySearchBehaviour>, assertionCreator: Assert<E>.() -> Unit): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.object(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> object(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
object only
object order
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> Assert<T>.property(property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.regex(pattern: String): AssertionPlant<T>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> Assert<T>.returnValueOf(method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
infix fun <T : CharSequence> Assert<T>.startsNotWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.startsWith(expected: CharSequence): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(values: Values<Any>): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(translatables: DefaultTranslationsOf): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.the(patterns: RegexPatterns): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(values: Values<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, values: Values<E>): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(objects: Objects<E>): AssertionPlant<T>
fun <E, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, objects: Objects<E>): AssertionPlant<T>
infix fun <E : Any, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.the(entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
fun <E : Any, T : Iterable<E>> the(builder: IterableContainsBuilder<E, T, InOrderOnlySearchBehaviour>, entries: Entries<E, Assert<E>.() -> Unit>): AssertionPlant<T>
infix fun <T : CharSequence> Assert<T>.to(contain: contain): Builder<T, NoOpSearchBehaviour>
infix fun <T : Any> Assert<T>.toBe(expected: T): AssertionPlant<T>
infix fun <T> AssertionPlantNullable<T>.toBe(null: Nothing?): Unit
infix fun <T : CharSequence> Assert<T>.toBe(Empty: Empty): AssertionPlant<T>
inline fun <reified TExpected : Throwable> Builder.toThrow(): Unit
inline infix fun <reified TExpected : Throwable> Builder.toThrow(noinline assertionCreator: Assert<TExpected>.() -> Unit): Unit
infix fun <T : CharSequence> CheckerOption<T, NoOpSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <T : CharSequence> CheckerOption<T, IgnoringCaseSearchBehaviour>.value(expected: Any): AssertionPlant<T>
infix fun <E, T : Iterable<E>> CheckerOption<E, T, InAnyOrderSearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(checkerBuilder: IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InAnyOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
fun <E, T : Iterable<E>> value(builder: IterableContainsBuilder<E, T, InAnyOrderOnlySearchBehaviour>, expected: E): AssertionPlant<T>
infix fun <E, T : Iterable<E>> Builder<E, T, InOrderOnlySearchBehaviour>.value(expected: E): AssertionPlant<T>
package ch.tutteli.atrium.api.cc.infix.en_UK.assertions.charsequence.contains.builders
Module Contents
open class CharSequenceContainsAtLeastCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsButAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsExactlyCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
open class CharSequenceContainsNotOrAtMostCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionImpl<T, S>, CharSequenceContainsCheckerBuilder<T, S>
fun nameContainsNotValuesFun(): String
package ch.tutteli.atrium.api.cc.infix.en_UK.assertions.iterable.contains.builders
Module Contents
open class IterableContainsAtLeastCheckerBuilder<out E, out T : Iterable<E>> : AtLeastCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsAtMostCheckerBuilder<out E, out T : Iterable<E>> : AtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsButAtMostCheckerBuilder<out E, out T : Iterable<E>> : ButAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsExactlyCheckerBuilder<out E, out T : Iterable<E>> : ExactlyCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotCheckerBuilder<out E, out T : Iterable<E>> : NotCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
open class IterableContainsNotOrAtMostCheckerBuilder<out E, out T : Iterable<E>> : NotOrAtMostCheckerOptionImpl<E, T, InAnyOrderSearchBehaviour>, IterableContainsCheckerBuilder<E, T, InAnyOrderSearchBehaviour>
package ch.tutteli.atrium.api.cc.infix.en_UK.creating.charsequence.contains.builders
Module Contents
interface AtLeastCheckerOption<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
open class AtLeastCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtLeastCheckerOptionBase<T, S>, AtLeastCheckerOption<T, S>
interface AtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class AtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : AtMostCheckerOptionBase<T, S>, AtMostCheckerOption<T, S>
interface ButAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ButAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ButAtMostCheckerOptionBase<T, S>, ButAtMostCheckerOption<T, S>
interface ExactlyCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class ExactlyCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : ExactlyCheckerOptionBase<T, S>, ExactlyCheckerOption<T, S>
interface NotCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotCheckerOptionBase<T, S>, NotCheckerOption<T, S>
interface NotOrAtMostCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
open class NotOrAtMostCheckerOptionImpl<out T : CharSequence, out S : SearchBehaviour> : NotOrAtMostCheckerOptionBase<T, S>, NotOrAtMostCheckerOption<T, S>
package ch.tutteli.atrium.api.cc.infix.en_UK.creating.iterable.contains.builders
Module Contents
interface AtLeastCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtLeastCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtLeastCheckerOptionBase<E, T, S>, AtLeastCheckerOption<E, T, S>
interface AtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class AtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : AtMostCheckerOptionBase<E, T, S>, AtMostCheckerOption<E, T, S>
interface ButAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ButAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ButAtMostCheckerOptionBase<E, T, S>, ButAtMostCheckerOption<E, T, S>
interface ExactlyCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class ExactlyCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : ExactlyCheckerOptionBase<E, T, S>, ExactlyCheckerOption<E, T, S>
interface NotCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
open class NotCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotCheckerOptionBase<E, T, S>, NotCheckerOption<E, T, S>
interface NotOrAtMostCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
open class NotOrAtMostCheckerOptionImpl<out E, out T : Iterable<E>, out S : InAnyOrderSearchBehaviour> : NotOrAtMostCheckerOptionBase<E, T, S>, NotOrAtMostCheckerOption<E, T, S>
package ch.tutteli.atrium.assertions
Module Contents
interface Assertion
interface AssertionGroup : Assertion
interface AssertionGroupType : BulletPointIdentifier
data class BasicAssertionGroup : AssertionGroup
class BasicDescriptiveAssertion : DescriptiveAssertion
class BasicExplanatoryAssertion : ExplanatoryAssertion
interface BulletPointIdentifier
object DefaultExplanatoryAssertionGroupType : ExplanatoryAssertionGroupType
object DefaultFeatureAssertionGroupType : FeatureAssertionGroupType
object DefaultIndentAssertionGroupType : IndentAssertionGroupType
object DefaultListAssertionGroupType : ListAssertionGroupType
object DefaultSummaryAssertionGroupType : SummaryAssertionGroupType
enum class DescriptionAnyAssertion : StringBasedTranslatable
enum class DescriptionBasic : StringBasedTranslatable
enum class DescriptionBigDecimalAssertion : StringBasedTranslatable
enum class DescriptionCharSequenceAssertion : StringBasedTranslatable
enum class DescriptionCollectionAssertion : StringBasedTranslatable
enum class DescriptionComparableAssertion : StringBasedTranslatable
enum class DescriptionFloatingPointAssertion : StringBasedTranslatable
enum class DescriptionIterableAssertion : StringBasedTranslatable
enum class DescriptionThrowableAssertion : StringBasedTranslatable
enum class DescriptionTypeTransformationAssertion : StringBasedTranslatable
interface DescriptiveAssertion : Assertion
interface DoNotFilterAssertionGroupType : AssertionGroupType
open class EmptyNameAndRepresentationAssertionGroup : AssertionGroup
interface ExplanatoryAssertion : Assertion
class ExplanatoryAssertionGroup : EmptyNameAndRepresentationAssertionGroup
interface ExplanatoryAssertionGroupType : DoNotFilterAssertionGroupType
interface FeatureAssertionGroupType : AssertionGroupType
class IndentAssertionGroup : EmptyNameAndRepresentationAssertionGroup
interface IndentAssertionGroupType : AssertionGroupType
class InvisibleAssertionGroup : EmptyNameAndRepresentationAssertionGroup
object InvisibleAssertionGroupType : AssertionGroupType
interface ListAssertionGroupType : AssertionGroupType
class PrefixFailingSummaryAssertion : BulletPointIdentifier
class PrefixFeatureAssertionGroupHeader : BulletPointIdentifier
class PrefixSuccessfulSummaryAssertion : BulletPointIdentifier
object RootAssertionGroupType : AssertionGroupType
interface SummaryAssertionGroupType : DoNotFilterAssertionGroupType
object WarningAssertionGroupType : ExplanatoryAssertionGroupType
fun <T : CharSequence> _containsBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
fun <T : CharSequence> _containsNotBuilder(plant: AssertionPlant<T>): <ERROR CLASS>
fun <T : Any, TSub : T> _downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> _endsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : CharSequence> _endsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : Collection<*>> _hasSize(plant: AssertionPlant<T>, size: Int): Assertion
inline fun <reified TSub : Any> _isA(plant: AssertionPlant<Any>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
fun <T : CharSequence> _isEmpty(plant: AssertionPlant<T>): Assertion
fun <T : BigDecimal> _isEqualIncludingScale(plant: AssertionPlant<T>, expected: T, nameOfIsNumericallyEqualTo: String): Assertion
fun <T : Comparable<T>> _isGreaterOrEquals(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Comparable<T>> _isGreaterThan(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Comparable<T>> _isLessOrEquals(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Comparable<T>> _isLessThan(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : CharSequence> _isNotEmpty(plant: AssertionPlant<T>): Assertion
fun <T : BigDecimal> _isNotEqualIncludingScale(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <reified T : Any> _isNotNull(plant: AssertionPlantNullable<T?>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): Unit
fun <T : BigDecimal> _isNotNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Any> _isNotSame(plant: AssertionPlant<T>, expected: T): Assertion
fun <T> _isNull(plant: AssertionPlantNullable<T>): Assertion
fun <T : BigDecimal> _isNumericallyEqualTo(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
fun <T : Any> _isSame(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: () -> TReturnValue, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1) -> TReturnValue, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2) -> TReturnValue, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _method(plant: AssertionPlant<T>, name: String, method: (T1, T2, T3, T4, T5) -> TReturnValue, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any> _notToBe(plant: AssertionPlant<T>, expected: T): Assertion
fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
fun <T : Any, TProperty : Any> _property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>): AssertionPlant<TReturnValue>
fun <T : Any, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction0<TReturnValue>, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1): AssertionPlant<TReturnValue>
fun <T : Any, T1, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction1<T1, TReturnValue>, arg1: T1, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction2<T1, T2, TReturnValue>, arg1: T1, arg2: T2, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<TReturnValue>
fun <T : Any, T1, T2, T3, T4, T5, TReturnValue : Any> _returnValueOf(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, TReturnValue>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, assertionCreator: AssertionPlant<TReturnValue>.() -> Unit): AssertionPlant<TReturnValue>
fun <T : CharSequence> _startsNotWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : CharSequence> _startsWith(plant: AssertionPlant<T>, expected: CharSequence): Assertion
fun <T : Any> _toBe(plant: AssertionPlant<T>, expected: T): Assertion
fun _toBeWithErrorTolerance(plant: AssertionPlant<Float>, expected: Float, tolerance: Float): Assertion
fun _toBeWithErrorTolerance(plant: AssertionPlant<Double>, expected: Double, tolerance: Double): Assertion
fun <T : BigDecimal> _toBeWithErrorTolerance(plant: AssertionPlant<T>, expected: T, tolerance: T): Assertion
fun <TExpected : Throwable> _toThrow(throwableThrownBuilder: <ERROR CLASS>, expectedType: KClass<TExpected>, assertionCreator: AssertionPlant<TExpected>.() -> Unit): Unit
fun <T : Any, TSub : Any> _typeTransformation(description: Translatable, representation: Any, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, warningTransformationFailed: Translatable, canBeTransformed: (T) -> Boolean, transform: (T) -> TSub): Unit
package ch.tutteli.atrium.assertions.any.typetransformation
package ch.tutteli.atrium.assertions.basic.contains
package ch.tutteli.atrium.assertions.basic.contains.builders
Module Contents
abstract class ContainsBuilder<out T : Any, out S : SearchBehaviour> : Builder<T, S>
interface ContainsCheckerBuilder<out T : Any, out S : SearchBehaviour, out C : Checker, out B : Builder<T, S>> : CheckerOption<T, S, C, B>
fun validateAtMost(times: Int, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
fun validateButAtMost(atLeastTimes: Int, butAtMostTimes: Int, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
package ch.tutteli.atrium.assertions.basic.contains.checkers
package ch.tutteli.atrium.assertions.basic.contains.creators
package ch.tutteli.atrium.assertions.builders
Module Contents
interface AssertionBuilder
interface AssertionBuilderFinalStep<T : Assertion>
interface AssertionGroupDescriptionAndEmptyRepresentationOption<out T : AssertionGroupType, R>
interface AssertionGroupDescriptionAndRepresentationOption<out T : AssertionGroupType, R>
interface AssertionsOption<out T : AssertionGroupType, out R>
Module Contents
fun <T : AssertionGroupType, R> create(groupType: T, description: Translatable, representation: Any, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
abstract val description: Translatable
fun <T : AssertionGroupType> factoryWithDefaultFinalStep(): (T, Translatable, Any) -> AssertionsOption<T, BasicAssertionGroupFinalStep>
abstract val groupType: T
abstract val representation: Any
open fun withAssertion(assertion: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion): R
open fun withAssertions(assertion1: Assertion, assertion2: Assertion, assertion3: Assertion): R
abstract fun withAssertions(assertions: List<Assertion>): R
fun <T : AssertionGroupType> withDefaultFinalStepAndEmptyDescriptionAndRepresentation(groupType: T): AssertionsOption<T, BasicAssertionGroupFinalStep>
fun <T : AssertionGroupType, R> withEmptyDescriptionAndRepresentation(groupType: T, factory: (T, Translatable, Any, List<Assertion>) -> R): AssertionsOption<T, R>
interface BasicAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
typealias DefaultAssertionGroupBuilderOptions<T> = AssertionGroupDescriptionAndRepresentationOption<T, AssertionsOption<T, BasicAssertionGroupFinalStep>>
interface Descriptive
interface Explanatory
interface ExplanatoryAssertionGroupFinalStep : AssertionBuilderFinalStep<AssertionGroup>
interface ExplanatoryAssertionGroupTypeOption
interface ExplanatoryGroup
val assertionBuilder: AssertionBuilder
val AssertionBuilder.invisibleGroup: AssertionsOption<InvisibleAssertionGroupType, BasicAssertionGroupFinalStep>
val AssertionBuilder.root: DefaultAssertionGroupBuilderOptions<RootAssertionGroupType>
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertion(translatable: Translatable): ExplanatoryAssertionGroupFinalStep
fun <T : ExplanatoryAssertionGroupType> AssertionsOption<T, ExplanatoryAssertionGroupFinalStep>.withExplanatoryAssertions(translatable: Translatable, arg: Any, vararg otherArgs: Any): ExplanatoryAssertionGroupFinalStep
package ch.tutteli.atrium.assertions.charsequence.contains
package ch.tutteli.atrium.assertions.charsequence.contains.builders
Module Contents
abstract class CharSequenceContainsAtLeastCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
class CharSequenceContainsBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<T, S>
abstract class CharSequenceContainsButAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
Module Contents
CharSequenceContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: CharSequenceContainsAtLeastCheckerBuilderBase<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: Builder<T, S>
val times: Int
interface CharSequenceContainsCheckerBuilder<out T : CharSequence, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<T, S>>, CheckerOption<T, S>
abstract class CharSequenceContainsExactlyCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsNotCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
abstract class CharSequenceContainsNotOrAtMostCheckerBuilderBase<out T : CharSequence, out S : SearchBehaviour> : CharSequenceContainsCheckerBuilder<T, S>
package ch.tutteli.atrium.assertions.charsequence.contains.checkers
package ch.tutteli.atrium.assertions.charsequence.contains.creators
Module Contents
class CharSequenceContainsAssertionCreator<T : CharSequence, S : SearchBehaviour> : ContainsObjectsAssertionCreator<T, Any, S, Checker>, Creator<T, Any>
fun <T : CharSequence> _containsDefaultTranslationOf(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: Translatable, otherExpected: Array<out Translatable>): AssertionGroup
fun <T : CharSequence> _containsDefaultTranslationOfIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: Translatable, otherExpected: Array<out Translatable>): AssertionGroup
fun <T : CharSequence> _containsRegex(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: String, otherExpected: Array<out String>): AssertionGroup
fun <T : CharSequence> _containsRegexIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: String, otherExpected: Array<out String>): AssertionGroup
fun <T : CharSequence> _containsValues(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsNoOpSearchBehaviour>, expected: Any, otherExpected: Array<out Any>): AssertionGroup
fun <T : CharSequence> _containsValuesIgnoringCase(checker: CharSequenceContainsCheckerBuilder<T, CharSequenceContainsIgnoringCaseSearchBehaviour>, expected: Any, otherExpected: Array<out Any>): AssertionGroup
package ch.tutteli.atrium.assertions.charsequence.contains.searchbehaviours
package ch.tutteli.atrium.assertions.charsequence.contains.searchers
package ch.tutteli.atrium.assertions.iterable.contains
package ch.tutteli.atrium.assertions.iterable.contains.builders
Module Contents
abstract class IterableContainsAtLeastCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
abstract class IterableContainsAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
open class IterableContainsBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsBuilder<T, S>, Builder<E, T, S>
abstract class IterableContainsButAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
Module Contents
IterableContainsButAtMostCheckerBuilderBase(times: Int, atLeastBuilder: IterableContainsAtLeastCheckerBuilderBase<E, T, S>, containsBuilder: IterableContainsBuilder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
open val containsBuilder: IterableContainsBuilder<E, T, S>
val times: Int
interface IterableContainsCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : ContainsCheckerBuilder<T, S, Checker, Builder<E, T, S>>, CheckerOption<E, T, S>
abstract class IterableContainsExactlyCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
class IterableContainsNoOpCheckerBuilder<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
abstract class IterableContainsNotCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
abstract class IterableContainsNotOrAtMostCheckerBuilderBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : IterableContainsCheckerBuilder<E, T, S>
package ch.tutteli.atrium.assertions.iterable.contains.checkers
package ch.tutteli.atrium.assertions.iterable.contains.creators
Module Contents
open class IterableContainsInAnyOrderEntriesAssertionCreator<E : Any, T : Iterable<E?>> : ContainsAssertionCreator<T, AssertionPlant<E>.() -> Unit, Checker>, Creator<T, AssertionPlant<E>.() -> Unit>
class IterableContainsInAnyOrderObjectsAssertionCreator<S, T : Iterable<S>> : ContainsObjectsAssertionCreator<T, S, IterableContainsInAnyOrderSearchBehaviour, Checker>, Creator<T, S>
abstract class IterableContainsInAnyOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>
class IterableContainsInAnyOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>
class IterableContainsInAnyOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInAnyOrderOnlyAssertionCreator<E, T, E>
abstract class IterableContainsInOrderOnlyAssertionCreator<E, T : Iterable<E?>, SC> : Creator<T, SC>
class IterableContainsInOrderOnlyEntriesAssertionCreator<E : Any, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, AssertionPlant<E>.() -> Unit>
class IterableContainsInOrderOnlyObjectsAssertionCreator<E, T : Iterable<E?>> : IterableContainsInOrderOnlyAssertionCreator<E, T, E>
fun <E : Any, T : Iterable<E>> _containsEntriesInAnyOrder(checker: IterableContainsCheckerBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E : Any, T : Iterable<E>> _containsEntriesInAnyOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E : Any, T : Iterable<E>> _containsEntriesInOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>, assertionCreator: AssertionPlant<E>.() -> Unit, otherAssertionCreators: Array<AssertionPlant<E>.() -> Unit>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInAnyOrder(checker: IterableContainsCheckerBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInAnyOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
fun <E, T : Iterable<E>> _containsObjectsInOrderOnly(builder: IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>, expected: E, otherExpected: Array<out E>): Assertion
package ch.tutteli.atrium.assertions.iterable.contains.searchbehaviours
Module Contents
open class IterableContainsInAnyOrderOnlySearchBehaviour : SearchBehaviour, InAnyOrderOnlySearchBehaviour
open class IterableContainsInAnyOrderSearchBehaviour : SearchBehaviour, InAnyOrderSearchBehaviour
open class IterableContainsInOrderOnlySearchBehaviour : SearchBehaviour, InOrderOnlySearchBehaviour
open class IterableContainsInOrderSearchBehaviour : SearchBehaviour, InOrderSearchBehaviour
open class IterableContainsNoOpSearchBehaviour : SearchBehaviour, NoOpSearchBehaviour
open class IterableContainsNotSearchBehaviour : IterableContainsInAnyOrderSearchBehaviour, NotSearchBehaviour
fun <E, T : Iterable<E>> _containsInAnyOrder(containsBuilder: IterableContainsBuilder<E, T, IterableContainsNoOpSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>
fun <E, T : Iterable<E>> _containsInAnyOrderOnly(containsBuilder: IterableContainsBuilder<E, T, IterableContainsInAnyOrderSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInAnyOrderOnlySearchBehaviour>
fun <E, T : Iterable<E>> _containsInOrder(containsBuilder: IterableContainsBuilder<E, T, IterableContainsNoOpSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInOrderSearchBehaviour>
fun <E, T : Iterable<E>> _containsInOrderOnly(containsBuilder: IterableContainsBuilder<E, T, IterableContainsInOrderSearchBehaviour>): IterableContainsBuilder<E, T, IterableContainsInOrderOnlySearchBehaviour>
package ch.tutteli.atrium.assertions.throwable.thrown
package ch.tutteli.atrium.assertions.throwable.thrown.builders
package ch.tutteli.atrium.assertions.throwable.thrown.creators
package ch.tutteli.atrium.assertions.throwable.thrown.providers
package ch.tutteli.atrium.checking
package ch.tutteli.atrium.core
Module Contents
expect interface CoreFactory : CoreFactoryCommon
interface CoreFactoryCommon
Module Contents
abstract fun newAssertionFormatterController(): AssertionFormatterController
abstract fun newAssertionFormatterFacade(assertionFormatterController: AssertionFormatterController): AssertionFormatterFacade
abstract fun <T : Any> newCheckingPlant(subjectProvider: () -> T): CheckingAssertionPlant<T>
abstract fun <T : Any> newCollectingPlant(subjectProvider: () -> T): CollectingAssertionPlant<T>
abstract fun <T> newCollectingPlantNullable(subjectProvider: () -> T): CollectingAssertionPlantNullable<T>
abstract fun <T> newDelegatingAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newDetailedObjectFormatter(translator: Translator): ObjectFormatter
abstract fun <T> newFeatureAssertionChecker(subjectPlant: BaseAssertionPlant<T, *>): AssertionChecker
abstract fun newLocaleOrderDecider(): LocaleOrderDecider
abstract fun newMethodCallFormatter(): MethodCallFormatter
abstract fun newMultiAtriumErrorAdjuster(firstAdjuster: AtriumErrorAdjuster, secondAdjuster: AtriumErrorAdjuster, otherAdjusters: List<AtriumErrorAdjuster>): AtriumErrorAdjuster
abstract fun newNoOpAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newOnlyFailureReporter(assertionFormatterFacade: AssertionFormatterFacade, atriumErrorAdjuster: AtriumErrorAdjuster): Reporter
abstract fun newRemoveAtriumFromAtriumErrorAdjuster(): AtriumErrorAdjuster
abstract fun newRemoveRunnerAtriumErrorAdjuster(): AtriumErrorAdjuster
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlant(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker): ReportingAssertionPlant<T>
abstract fun <T : Any> newReportingPlant(commonFields: CommonFields<T>): ReportingAssertionPlant<T>
open fun <T : Any> newReportingPlantAndAddAssertionsCreatedBy(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, assertionCreator: AssertionPlant<T>.() -> Unit): AssertionPlant<T>
abstract fun <T> newReportingPlantNullable(commonFields: CommonFields<T>): ReportingAssertionPlantNullable<T>
abstract fun newTextExplanatoryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController): AssertionFormatter
abstract fun newTextFallbackAssertionFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextFeatureAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextListAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newTextNextLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSameLineAssertionPairFormatter(objectFormatter: ObjectFormatter, translator: Translator): AssertionPairFormatter
abstract fun newTextSummaryAssertionGroupFormatter(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterController: AssertionFormatterController, objectFormatter: ObjectFormatter, translator: Translator): AssertionFormatter
abstract fun newThrowingAssertionChecker(reporter: Reporter): AssertionChecker
abstract fun newTranslator(translationSupplier: TranslationSupplier, localeOrderDecider: LocaleOrderDecider, primaryLocale: Locale, fallbackLocales: List<Locale>): Translator
abstract fun registerTextAssertionFormatterCapabilities(bulletPoints: Map<KClass<out BulletPointIdentifier>, String>, assertionFormatterFacade: AssertionFormatterFacade, textAssertionPairFormatter: AssertionPairFormatter, objectFormatter: ObjectFormatter, translator: Translator): Unit
val coreFactory: <ERROR CLASS>
val falseProvider: () -> Boolean
kotlin.Function0
fun <T> CoreFactoryCommon.newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, reporter: Reporter, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
fun <T> CoreFactoryCommon.newReportingPlantNullable(assertionVerb: Translatable, subjectProvider: () -> T, assertionChecker: AssertionChecker, nullRepresentation: Any = RawString.NULL): ReportingAssertionPlantNullable<T>
val trueProvider: () -> Boolean
package ch.tutteli.atrium.core.migration
package ch.tutteli.atrium.core.polyfills
package ch.tutteli.atrium.creating
Module Contents
typealias Assert<T> = AssertionPlant<T>
@DslMarker annotation class AssertMarker
interface AssertionPlant<out T : Any> : BaseAssertionPlant<T, AssertionPlant<T>>
interface AssertionPlantNullable<out T> : BaseAssertionPlant<T, AssertionPlantNullable<T>>
interface AssertionPlantWithCommonFields<out T>
interface BaseAssertionPlant<out T, out A : BaseAssertionPlant<T, A>>
interface BaseCollectingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>, out C : BaseCollectingAssertionPlant<T, A, C>> : BaseAssertionPlant<T, A>
interface BaseReportingAssertionPlant<out T, out A : BaseAssertionPlant<T, A>> : BaseAssertionPlant<T, A>, AssertionPlantWithCommonFields<T>
interface CheckingAssertionPlant<out T : Any> : AssertionPlant<T>
interface CollectingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseCollectingAssertionPlant<T, AssertionPlant<T>, CollectingAssertionPlant<T>>
interface CollectingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseCollectingAssertionPlant<T, AssertionPlantNullable<T>, CollectingAssertionPlantNullable<T>>
sealed class MaybeSubject<out T>
class PlantHasNoSubjectException : RuntimeException
interface ReportingAssertionPlant<out T : Any> : AssertionPlant<T>, BaseReportingAssertionPlant<T, AssertionPlant<T>>
interface ReportingAssertionPlantNullable<out T> : AssertionPlantNullable<T>, BaseReportingAssertionPlant<T, AssertionPlantNullable<T>>
package ch.tutteli.atrium.domain.assertions.composers
package ch.tutteli.atrium.domain.builders
package ch.tutteli.atrium.domain.builders.assertions.builders
package ch.tutteli.atrium.domain.builders.creating
Module Contents
object AbsentThrowableMessageProviderFactoryBuilder : AbsentThrowableMessageProviderFactory
object AnyAssertionsBuilder : AnyAssertions
Module Contents
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNotNullBut(plant: AssertionPlantNullable<T?>, type: KClass<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> isNotSame(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T> isNull(plant: AssertionPlantNullable<T>): <ERROR CLASS>
inline fun <T : Any> isNullIfNullGivenElse(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreatorOrNull: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNullable(plant: AssertionPlantNullable<T?>, type: KClass<T>, expectedOrNull: T?): <ERROR CLASS>
inline fun <T : Any> isSame(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> notToBe(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline fun <T : Any> toBe(plant: AssertionPlant<T>, expected: T): <ERROR CLASS>
inline val typeTransformation: AnyTypeTransformationAssertionsBuilder
object AnyTypeTransformationAssertionsBuilder : AnyTypeTransformationAssertions
Module Contents
inline fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): <ERROR CLASS>
inline val failureHandlers: AnyTypeTransformationFailureHandlerFactoryBuilder
inline fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, noinline assertionCreator: AssertionPlant<TSub>.() -> Unit): <ERROR CLASS>
inline fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, noinline assertionCreator: AssertionPlant<T>.() -> Unit): <ERROR CLASS>
inline fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, noinline canBeTransformed: (S) -> Boolean, noinline transform: (S) -> T, failureHandler: FailureHandler<S, T>): <ERROR CLASS>
object AnyTypeTransformationFailureHandlerFactoryBuilder : FailureHandlerFactory
object BigDecimalAssertionsBuilder : BigDecimalAssertions
object CharSequenceAssertionsBuilder : CharSequenceAssertions
object CharSequenceContainsAssertionsBuilder : CharSequenceContainsAssertions
Module Contents
inline fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): <ERROR CLASS>
inline fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): <ERROR CLASS>
inline val searchBehaviours: CharSequenceContainsSearchBehaviourFactoryBuilder
inline fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
inline fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): <ERROR CLASS>
object CharSequenceContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory
object CollectionAssertionsBuilder : CollectionAssertions
object ComparableAssertionsBuilder : ComparableAssertions
object FeatureAssertionsBuilder : FeatureAssertions
Module Contents
inline val extractor: RepresentationOption
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable, noinline assertionCreator: AssertionPlant<TProperty>.() -> Unit): AssertionPlant<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty1<T, TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, property: KProperty0<TProperty>): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, TProperty> property(plant: AssertionPlant<T>, noinline subjectProvider: () -> TProperty, noinline representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction1<T, R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: KFunction0<R>): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, name: String): AssertionPlantNullable<R>
inline fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, noinline method: () -> R, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction2<T, T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: KFunction1<T1, R>, arg1: T1): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, noinline method: (T1) -> R, arg1: T1, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction3<T, T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: KFunction2<T1, T2, R>, arg1: T1, arg2: T2): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, noinline method: (T1, T2) -> R, arg1: T1, arg2: T2, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction4<T, T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: KFunction3<T1, T2, T3, R>, arg1: T1, arg2: T2, arg3: T3): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, noinline method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction5<T, T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: KFunction4<T1, T2, T3, T4, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String, noinline assertionCreator: AssertionPlant<R>.() -> Unit): AssertionPlant<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction6<T, T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: KFunction5<T1, T2, T3, T4, T5, R>, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
inline fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, noinline method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, noinline representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
expect object FloatingPointAssertionsBuilder : FloatingPointAssertions
object IterableAssertionsBuilder : IterableAssertions
object IterableContainsAssertionsBuilder : IterableContainsAssertions
Module Contents
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): <ERROR CLASS>
inline fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
inline val searchBehaviours: IterableContainsSearchBehaviourFactoryBuilder
inline fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion
object IterableContainsSearchBehaviourFactoryBuilder : SearchBehaviourFactory
Module Contents
inline fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): <ERROR CLASS>
inline fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): <ERROR CLASS>
object ListAssertionsBuilder : ListAssertions
object MapAssertionsBuilder : MapAssertions
Module Contents
inline fun <K, V> contains(plant: AssertionPlant<Map<out K, V>>, keyValuePairs: List<<ERROR CLASS><K, V>>): Assertion
inline fun <K> containsKey(plant: AssertionPlant<Map<out K, *>>, key: K): <ERROR CLASS>
inline fun <K, V : Any> containsKeyWithValueAssertions(plant: AssertionPlant<Map<out K, V?>>, keyValues: List<<ERROR CLASS><K, Assert<V>.() -> Unit>>): <ERROR CLASS>
inline fun <K> containsNotKey(plant: AssertionPlant<Map<out K, *>>, key: K): <ERROR CLASS>
inline val entry: MapEntryAssertionsBuilder
inline fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K): <ERROR CLASS>
inline fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K, noinline assertionCreator: AssertionPlant<V>.() -> Unit): <ERROR CLASS>
inline fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K): <ERROR CLASS>
inline fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): <ERROR CLASS>
inline fun hasSize(plant: AssertionPlant<Map<*, *>>, size: Int): <ERROR CLASS>
inline fun isEmpty(plant: AssertionPlant<Map<*, *>>): <ERROR CLASS>
inline fun isNotEmpty(plant: AssertionPlant<Map<*, *>>): <ERROR CLASS>
inline fun <K> keys(plant: AssertionPlant<Map<out K, *>>, noinline assertionCreator: AssertionPlant<Set<K>>.() -> Unit): Assertion
inline fun <V> values(plant: AssertionPlant<Map<*, V>>, noinline assertionCreator: AssertionPlant<Collection<V>>.() -> Unit): Assertion
object MapEntryAssertionsBuilder : MapEntryAssertions
Module Contents
inline fun <K : Any, V : Any> isKeyValue(plant: AssertionPlant<Entry<K, V>>, key: K, value: V): Assertion
inline fun <K : Any> key(plant: AssertionPlant<Entry<K, *>>, noinline assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
inline fun <K> nullableKey(plant: AssertionPlant<Entry<K, *>>, noinline assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
inline fun <V> nullableValue(plant: AssertionPlant<Entry<*, V>>, noinline assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
inline fun <V : Any> value(plant: AssertionPlant<Entry<*, V>>, noinline assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
object PairAssertionsBuilder : PairAssertions
class PleaseUseReplacementException : Exception
object ThrowableAssertionsBuilder : ThrowableAssertions
object ThrowableThrownAssertionsBuilder : ThrowableThrownAssertions
package ch.tutteli.atrium.domain.builders.creating.charsequence.contains.builders
Module Contents
abstract class AtLeastCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class AtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class ButAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
Module Contents
ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<T, S>, containsBuilder: Builder<T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<T, S>
val times: Int
abstract class ExactlyCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
abstract class NotCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
abstract class NotOrAtMostCheckerOptionBase<out T : CharSequence, out S : SearchBehaviour> : WithTimesCheckerOption<T, S>
interface WithTimesCheckerOption<out T : CharSequence, out S : SearchBehaviour> : CheckerOption<T, S>
package ch.tutteli.atrium.domain.builders.creating.collectors
Module Contents
object AssertionCollectorBuilder : AssertionCollector
Module Contents
inline fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(noinline subjectProvider: () -> T, noinline collectingPlantFactory: (() -> T) -> C, noinline assertionCreator: C.() -> Unit): AssertionGroup
inline fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, noinline subjectProvider: () -> T, noinline collectingPlantFactory: (() -> T) -> C, noinline assertionCreator: C.() -> Unit): AssertionGroup
inline val forExplanation: ExplainingAssertionCollectorOption
object ExplainingAssertionCollectorOption
package ch.tutteli.atrium.domain.builders.creating.iterable.contains.builders
Module Contents
abstract class AtLeastCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class AtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class ButAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
Module Contents
ButAtMostCheckerOptionBase(times: Int, atLeastBuilder: WithTimesCheckerOption<E, T, S>, containsBuilder: Builder<E, T, S>, nameContainsNotFun: String, atLeastButAtMostCall: (Int, Int) -> String, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String)
open val checkers: List<Checker>
val containsBuilder: Builder<E, T, S>
val times: Int
abstract class ExactlyCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
abstract class NotCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
abstract class NotOrAtMostCheckerOptionBase<out E, out T : Iterable<E>, out S : SearchBehaviour> : WithTimesCheckerOption<E, T, S>
interface WithTimesCheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<E, T, S>
package ch.tutteli.atrium.domain.builders.reporting
package ch.tutteli.atrium.domain.builders.utils
Module Contents
class ArgumentMapperBuilder<out T>
class ArgumentToNullOrMapperBuilder<T : Any>
interface Group<out T>
interface GroupWithNullableEntries<out T> : Group<T>
interface GroupWithoutNullableEntries<out T> : Group<T>
interface VarArgHelper<out T>
fun <T> groupsToList(firstGroup: Group<T>, secondGroup: Group<T>, otherGroups: Array<out Group<T>>): List<List<T>>
fun <T> mapArguments(first: T, others: Array<out T>): ArgumentMapperBuilder<T>
inline fun <T, reified R> mapArguments(first: T, others: Array<out T>, mapper: (T) -> R): <ERROR CLASS><R, Array<out R>>
fun mapArguments(first: Byte, others: ByteArray): ArgumentMapperBuilder<Byte>
inline fun <reified R> mapArguments(first: Byte, others: ByteArray, mapper: (Byte) -> R): <ERROR CLASS><R, Array<out R>>
fun mapArguments(first: Char, others: CharArray): ArgumentMapperBuilder<Char>
inline fun <reified R> mapArguments(first: Char, others: CharArray, mapper: (Char) -> R): <ERROR CLASS><R, Array<out R>>
fun mapArguments(first: Short, others: ShortArray): ArgumentMapperBuilder<Short>
inline fun <reified R> mapArguments(first: Short, others: ShortArray, mapper: (Short) -> R): <ERROR CLASS><R, Array<out R>>
fun mapArguments(first: Int, others: IntArray): ArgumentMapperBuilder<Int>
inline fun <reified R> mapArguments(first: Int, others: IntArray, mapper: (Int) -> R): <ERROR CLASS><R, Array<out R>>
fun mapArguments(first: Long, others: LongArray): ArgumentMapperBuilder<Long>
inline fun <reified R> mapArguments(first: Long, others: LongArray, mapper: (Long) -> R): <ERROR CLASS><R, Array<out R>>
fun mapArguments(first: Float, others: FloatArray): ArgumentMapperBuilder<Float>
inline fun <reified R> mapArguments(first: Float, others: FloatArray, mapper: (Float) -> R): <ERROR CLASS><R, Array<out R>>
fun mapArguments(first: Double, others: DoubleArray): ArgumentMapperBuilder<Double>
inline fun <reified R> mapArguments(first: Double, others: DoubleArray, mapper: (Double) -> R): <ERROR CLASS><R, Array<out R>>
fun mapArguments(first: Boolean, others: BooleanArray): ArgumentMapperBuilder<Boolean>
inline fun <reified R> mapArguments(first: Boolean, others: BooleanArray, mapper: (Boolean) -> R): <ERROR CLASS><R, Array<out R>>
inline fun <T> nullable(t: T): T?
inline fun <T> nullable(t: KFunction0<T>): KFunction0<T?>
inline fun <T1, R> nullable(t: KFunction1<T1, R>): KFunction1<T1, R?>
inline fun <T1, T2, R> nullable(t: KFunction2<T1, T2, R>): KFunction2<T1, T2, R?>
inline fun <T1, T2, T3, R> nullable(t: KFunction3<T1, T2, T3, R>): KFunction3<T1, T2, T3, R?>
inline fun <T1, T2, T3, T4, R> nullable(t: KFunction4<T1, T2, T3, T4, R>): KFunction4<T1, T2, T3, T4, R?>
inline fun <T1, T2, T3, T4, T5, R> nullable(t: KFunction5<T1, T2, T3, T4, T5, R>): KFunction5<T1, T2, T3, T4, T5, R?>
inline fun <T> nullableContainer(iterable: Iterable<T>): Iterable<T?>
inline fun <T> nullableContainer(arr: Array<out T>): Array<out T?>
inline fun <K, V : Any> nullableKeyMap(map: Map<out K, V>): Map<out K?, V>
inline fun <K, V> nullableKeyValueMap(map: Map<out K, V>): Map<out K?, V?>
inline fun <K : Any, V> nullableValueMap(map: Map<K, V>): Map<K, V?>
inline fun <T : Any> subAssert(noinline assertionCreator: Assert<T>.() -> Unit): Assert<T>.() -> Unit
inline fun <T> subAssertNullable(noinline assertionCreator: AssertionPlantNullable<T>.() -> Unit): AssertionPlantNullable<T>.() -> Unit
fun <T : Any> ArgumentMapperBuilder<T?>.toNullOr(): ArgumentToNullOrMapperBuilder<T>
fun validateAtMost(times: Int, atMostCall: (Int) -> String, atLeastCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
fun validateButAtMost(atLeastTimes: Int, butAtMostTimes: Int, atLeastButAtMostCall: (Int, Int) -> String, atLeastCall: (Int) -> String, butAtMostCall: (Int) -> String, exactlyCall: (Int) -> String): Unit
package ch.tutteli.atrium.domain.creating
Module Contents
interface AnyAssertions
Module Contents
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Assertion
abstract fun <T : Any> isNotNullBut(plant: AssertionPlantNullable<T?>, type: KClass<T>, expected: T): Assertion
abstract fun <T : Any> isNotSame(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T> isNull(plant: AssertionPlantNullable<T>): Assertion
abstract fun <T : Any> isNullIfNullGivenElse(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreatorOrNull: AssertionPlant<T>.() -> Unit): Assertion
abstract fun <T : Any> isNullable(plant: AssertionPlantNullable<T?>, type: KClass<T>, expectedOrNull: T?): Assertion
abstract fun <T : Any> isSame(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : Any> notToBe(plant: AssertionPlant<T>, expected: T): Assertion
abstract fun <T : Any> toBe(plant: AssertionPlant<T>, expected: T): Assertion
interface BigDecimalAssertions
interface CharSequenceAssertions
interface CollectionAssertions
interface ComparableAssertions
interface FeatureAssertions
Module Contents
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty : Any> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlant<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, TProperty> property(plant: AssertionPlant<T>, subjectProvider: () -> TProperty, representationProvider: () -> Any?, name: Translatable): AssertionPlantNullable<TProperty>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlant<R>
abstract fun <T : Any, R : Any> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, R> returnValueOf0(plant: AssertionPlant<T>, method: () -> R, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R : Any> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, R> returnValueOf1(plant: AssertionPlant<T>, method: (T1) -> R, arg1: T1, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R : Any> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, R> returnValueOf2(plant: AssertionPlant<T>, method: (T1, T2) -> R, arg1: T1, arg2: T2, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R : Any> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, R> returnValueOf3(plant: AssertionPlant<T>, method: (T1, T2, T3) -> R, arg1: T1, arg2: T2, arg3: T3, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R : Any> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, R> returnValueOf4(plant: AssertionPlant<T>, method: (T1, T2, T3, T4) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R : Any> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlant<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, name: String): AssertionPlantNullable<R>
abstract fun <T : Any, T1, T2, T3, T4, T5, R> returnValueOf5(plant: AssertionPlant<T>, method: (T1, T2, T3, T4, T5) -> R, arg1: T1, arg2: T2, arg3: T3, arg4: T4, arg5: T5, representationProvider: () -> Any?, name: String): AssertionPlantNullable<R>
expect interface FloatingPointAssertions : FloatingPointAssertionsCommon
interface FloatingPointAssertionsCommon
interface IterableAssertions
interface ListAssertions
interface MapAssertions
Module Contents
abstract fun <K, V> contains(plant: AssertionPlant<Map<out K, V>>, keyValuePairs: List<<ERROR CLASS><K, V>>): Assertion
abstract fun <K> containsKey(plant: AssertionPlant<Map<out K, *>>, key: K): Assertion
abstract fun <K, V : Any> containsKeyWithValueAssertions(plant: AssertionPlant<Map<out K, V?>>, keyValues: List<<ERROR CLASS><K, Assert<V>.() -> Unit>>): Assertion
abstract fun <K> containsNotKey(plant: AssertionPlant<Map<out K, *>>, key: K): Assertion
abstract fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlant<V>
abstract fun <K, V : Any> getExisting(plant: AssertionPlant<Map<out K, V>>, key: K, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
abstract fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K): AssertionPlantNullable<V>
abstract fun <K, V> getExistingNullable(plant: AssertionPlant<Map<out K, V>>, key: K, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun hasSize(plant: AssertionPlant<Map<*, *>>, size: Int): Assertion
abstract fun isEmpty(plant: AssertionPlant<Map<*, *>>): Assertion
abstract fun isNotEmpty(plant: AssertionPlant<Map<*, *>>): Assertion
abstract fun <K> keys(plant: AssertionPlant<Map<out K, *>>, assertionCreator: AssertionPlant<Set<K>>.() -> Unit): Assertion
abstract fun <V> values(plant: AssertionPlant<Map<*, V>>, assertionCreator: AssertionPlant<Collection<V>>.() -> Unit): Assertion
interface MapEntryAssertions
Module Contents
abstract fun <K : Any, V : Any> isKeyValue(plant: AssertionPlant<Entry<K, V>>, key: K, value: V): Assertion
abstract fun <K : Any> key(plant: AssertionPlant<Entry<K, *>>, assertionCreator: AssertionPlant<K>.() -> Unit): Assertion
abstract fun <K> nullableKey(plant: AssertionPlant<Entry<K, *>>, assertionCreator: AssertionPlantNullable<K>.() -> Unit): Assertion
abstract fun <V> nullableValue(plant: AssertionPlant<Entry<*, V>>, assertionCreator: AssertionPlantNullable<V>.() -> Unit): Assertion
abstract fun <V : Any> value(plant: AssertionPlant<Entry<*, V>>, assertionCreator: AssertionPlant<V>.() -> Unit): Assertion
interface PairAssertions
interface ThrowableAssertions
val anyAssertions: <ERROR CLASS>
val bigDecimalAssertions: <ERROR CLASS>
val charSequenceAssertions: <ERROR CLASS>
val collectionAssertions: <ERROR CLASS>
val comparableAssertions: <ERROR CLASS>
val featureAssertions: <ERROR CLASS>
val floatingPointAssertions: <ERROR CLASS>
val iterableAssertions: <ERROR CLASS>
val listAssertions: <ERROR CLASS>
val mapAssertions: <ERROR CLASS>
val mapEntryAssertions: <ERROR CLASS>
val pairAssertions: <ERROR CLASS>
val throwableAssertions: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.any.typetransformation
package ch.tutteli.atrium.domain.creating.any.typetransformation.creators
Module Contents
interface AnyTypeTransformationAssertions
Module Contents
abstract fun <T : Any, TSub : T> downCast(description: Translatable, subType: KClass<TSub>, subjectPlant: BaseAssertionPlant<T?, *>, assertionCreator: AssertionPlant<TSub>.() -> Unit, failureHandler: FailureHandler<T, TSub>): Unit
abstract fun <TSub : Any> isA(plant: AssertionPlant<Any>, subType: KClass<TSub>, assertionCreator: AssertionPlant<TSub>.() -> Unit): Unit
abstract fun <T : Any> isNotNull(plant: AssertionPlantNullable<T?>, type: KClass<T>, assertionCreator: AssertionPlant<T>.() -> Unit): Unit
abstract fun <S : Any, T : Any> transform(parameterObject: ParameterObject<S, T>, canBeTransformed: (S) -> Boolean, transform: (S) -> T, failureHandler: FailureHandler<S, T>): Unit
val anyTypeTransformationAssertions: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.any.typetransformation.failurehandlers
package ch.tutteli.atrium.domain.creating.basic.contains
package ch.tutteli.atrium.domain.creating.charsequence.contains
package ch.tutteli.atrium.domain.creating.charsequence.contains.checkers
package ch.tutteli.atrium.domain.creating.charsequence.contains.creators
Module Contents
interface CharSequenceContainsAssertions
Module Contents
abstract fun <T : CharSequence> defaultTranslationOf(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> defaultTranslationOfIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Translatable>): AssertionGroup
abstract fun <T : CharSequence> regex(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> regexIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<String>): AssertionGroup
abstract fun <T : CharSequence> values(checkerOption: CheckerOption<T, NoOpSearchBehaviour>, expected: List<Any>): AssertionGroup
abstract fun <T : CharSequence> valuesIgnoringCase(checkerOption: CheckerOption<T, IgnoringCaseSearchBehaviour>, expected: List<Any>): AssertionGroup
val charSequenceContainsAssertions: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.charsequence.contains.searchbehaviours
package ch.tutteli.atrium.domain.creating.collectors
Module Contents
interface AssertionCollector
Module Contents
open fun <T : Any> collect(plant: AssertionPlant<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
open fun <T : Any> collect(subjectProvider: () -> T, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(subjectProvider: () -> T, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): AssertionGroup
open fun <T> collectNullable(plant: AssertionPlantNullable<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullable(subjectProvider: () -> T, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullableOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, plant: AssertionPlantNullable<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T> collectNullableOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): AssertionGroup
open fun <T : Any> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, plant: AssertionPlant<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
open fun <T : Any> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): AssertionGroup
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collectOrExplain(safeToCollect: Boolean, warningCannotEvaluate: Translatable, subjectProvider: () -> T, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): AssertionGroup
interface AssertionCollectorForExplanation
Module Contents
open fun <T : Any> collect(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, assertionCreator: CollectingAssertionPlant<T>.() -> Unit): List<Assertion>
abstract fun <T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>> collect(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, collectingPlantFactory: (() -> T) -> C, assertionCreator: C.() -> Unit): List<Assertion>
open fun <T> collectNullable(warningCannotEvaluate: Translatable, maybeSubject: MaybeSubject<T>, assertionCreator: CollectingAssertionPlantNullable<T>.() -> Unit): List<Assertion>
interface NonThrowingAssertionCollectorForExplanation : AssertionCollectorForExplanation
interface ThrowingAssertionCollectorForExplanation : AssertionCollectorForExplanation
val assertionCollector: AssertionCollector
val nonThrowingAssertionCollectorForExplanation: NonThrowingAssertionCollectorForExplanation
val throwingAssertionCollectorForExplanation: ThrowingAssertionCollectorForExplanation
package ch.tutteli.atrium.domain.creating.feature.extract
Module Contents
interface FeatureExtractor
Module Contents
interface Creator<TSubject, T : Any> : CreatorLike<TSubject, T, AssertionPlant<T>, CollectingAssertionPlant<T>>
interface CreatorLike<TSubject, T, A : BaseAssertionPlant<T, A>, C : BaseCollectingAssertionPlant<T, A, C>>
interface CreatorNullable<TSubject, T> : CreatorLike<TSubject, T, AssertionPlantNullable<T>, CollectingAssertionPlantNullable<T>>
data class ParameterObject<TSubject, T>
interface ParameterObjectOption
interface RepresentationOption
val builder: RepresentationOption
package ch.tutteli.atrium.domain.creating.feature.extract.creators
package ch.tutteli.atrium.domain.creating.iterable.contains
Module Contents
interface IterableContains
Module Contents
interface Builder<out E, out T : Iterable<E>, out S : SearchBehaviour> : Builder<T, S>
interface Checker : Checker
interface CheckerOption<out E, out T : Iterable<E>, out S : SearchBehaviour> : CheckerOption<T, S, Checker, Builder<E, T, S>>
interface Creator<in T : Iterable<*>, in SC> : Creator<T, SC>
interface SearchBehaviour : SearchBehaviour
fun <E, T : Iterable<E>, S : SearchBehaviour> CheckerOption<E, T, S>.addAssertion(assertion: Assertion): AssertionPlant<T>
package ch.tutteli.atrium.domain.creating.iterable.contains.checkers
package ch.tutteli.atrium.domain.creating.iterable.contains.creators
Module Contents
interface IterableContainsAssertions
Module Contents
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrder(checkerOption: CheckerOption<E?, T, InAnyOrderSearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInAnyOrderOnly(builder: Builder<E?, T, InAnyOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnly(builder: Builder<E?, T, InOrderOnlySearchBehaviour>, assertionCreators: List<AssertionPlant<E>.() -> Unit>): Assertion
abstract fun <E : Any, T : Iterable<E?>> entriesInOrderOnlyGrouped(builder: Builder<E?, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<AssertionPlant<E>.() -> Unit>>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrder(checkerOption: CheckerOption<E, T, InAnyOrderSearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInAnyOrderOnly(builder: Builder<E, T, InAnyOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnly(builder: Builder<E, T, InOrderOnlySearchBehaviour>, expected: List<E>): Assertion
abstract fun <E, T : Iterable<E>> valuesInOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>, groups: List<List<E>>): Assertion
val iterableContainsAssertions: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.iterable.contains.searchbehaviours
Module Contents
interface InAnyOrderOnlySearchBehaviour : SearchBehaviour
interface InAnyOrderSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedSearchBehaviour : SearchBehaviour
interface InOrderOnlyGroupedWithinSearchBehaviour : InOrderOnlyGroupedSearchBehaviour
interface InOrderOnlySearchBehaviour : SearchBehaviour
interface InOrderSearchBehaviour : SearchBehaviour
interface NoOpSearchBehaviour : SearchBehaviour
interface NotSearchBehaviour : InAnyOrderSearchBehaviour
interface SearchBehaviourFactory
Module Contents
abstract fun <E, T : Iterable<E>> inAnyOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InAnyOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inAnyOrderOnly(builder: Builder<E, T, InAnyOrderSearchBehaviour>): Builder<E, T, InAnyOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrder(builder: Builder<E, T, NoOpSearchBehaviour>): Builder<E, T, InOrderSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnly(builder: Builder<E, T, InOrderSearchBehaviour>): Builder<E, T, InOrderOnlySearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGrouped(builder: Builder<E, T, InOrderOnlySearchBehaviour>): Builder<E, T, InOrderOnlyGroupedSearchBehaviour>
abstract fun <E, T : Iterable<E>> inOrderOnlyGroupedWithin(builder: Builder<E, T, InOrderOnlyGroupedSearchBehaviour>): Builder<E, T, InOrderOnlyGroupedWithinSearchBehaviour>
val searchBehaviourFactory: <ERROR CLASS>
package ch.tutteli.atrium.domain.creating.throwable.thrown
package ch.tutteli.atrium.domain.creating.throwable.thrown.creators
package ch.tutteli.atrium.domain.creating.throwable.thrown.providers
package ch.tutteli.atrium.reporting
package ch.tutteli.atrium.reporting.translating
package ch.tutteli.atrium.spec
package ch.tutteli.atrium.translations
package ch.tutteli.atrium.verbs
package ch.tutteli.atrium.verbs.assert
package ch.tutteli.atrium.verbs.assertthat
package ch.tutteli.atrium.verbs.expect
package ch.tutteli.atrium.verbs.internal